![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
1 /* Copyright (c) 2006 Jonas Fonseca <fonseca@diku.dk>
2 *
3 * This program is free software; you can redistribute it and/or
4 * modify it under the terms of the GNU General Public License as
5 * published by the Free Software Foundation; either version 2 of
6 * the License, or (at your option) any later version.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 */
13 /**
14 * TIG(1)
15 * ======
16 *
17 * NAME
18 * ----
19 * tig - text-mode interface for git
20 *
21 * SYNOPSIS
22 * --------
23 * [verse]
24 * tig [options]
25 * tig [options] [--] [git log options]
26 * tig [options] log [git log options]
27 * tig [options] diff [git diff options]
28 * tig [options] show [git show options]
29 * tig [options] < [git command output]
30 *
31 * DESCRIPTION
32 * -----------
33 * Browse changes in a git repository. Additionally, tig(1) can also act
34 * as a pager for output of various git commands.
35 *
36 * When browsing repositories, tig(1) uses the underlying git commands
37 * to present the user with various views, such as summarized commit log
38 * and showing the commit with the log message, diffstat, and the diff.
39 *
40 * Using tig(1) as a pager, it will display input from stdin and try
41 * to colorize it.
42 **/
44 #ifndef VERSION
45 #define VERSION "tig-0.3"
46 #endif
48 #ifndef DEBUG
49 #define NDEBUG
50 #endif
52 #include <assert.h>
53 #include <errno.h>
54 #include <ctype.h>
55 #include <signal.h>
56 #include <stdarg.h>
57 #include <stdio.h>
58 #include <stdlib.h>
59 #include <string.h>
60 #include <unistd.h>
61 #include <time.h>
63 #include <curses.h>
65 static void die(const char *err, ...);
66 static void report(const char *msg, ...);
67 static int read_properties(FILE *pipe, const char *separators, int (*read)(char *, int, char *, int));
68 static void set_nonblocking_input(bool loading);
69 static size_t utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed);
71 #define ABS(x) ((x) >= 0 ? (x) : -(x))
72 #define MIN(x, y) ((x) < (y) ? (x) : (y))
74 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
75 #define STRING_SIZE(x) (sizeof(x) - 1)
77 #define SIZEOF_REF 256 /* Size of symbolic or SHA1 ID. */
78 #define SIZEOF_CMD 1024 /* Size of command buffer. */
80 /* This color name can be used to refer to the default term colors. */
81 #define COLOR_DEFAULT (-1)
83 #define TIG_HELP "(d)iff, (l)og, (m)ain, (q)uit, (h)elp"
85 /* The format and size of the date column in the main view. */
86 #define DATE_FORMAT "%Y-%m-%d %H:%M"
87 #define DATE_COLS STRING_SIZE("2006-04-29 14:21 ")
89 #define AUTHOR_COLS 20
91 /* The default interval between line numbers. */
92 #define NUMBER_INTERVAL 1
94 #define TABSIZE 8
96 #define SCALE_SPLIT_VIEW(height) ((height) * 2 / 3)
98 /* Some ascii-shorthands fitted into the ncurses namespace. */
99 #define KEY_TAB '\t'
100 #define KEY_RETURN '\r'
101 #define KEY_ESC 27
104 /* User action requests. */
105 enum request {
106 /* Offset all requests to avoid conflicts with ncurses getch values. */
107 REQ_OFFSET = KEY_MAX + 1,
109 /* XXX: Keep the view request first and in sync with views[]. */
110 REQ_VIEW_MAIN,
111 REQ_VIEW_DIFF,
112 REQ_VIEW_LOG,
113 REQ_VIEW_HELP,
114 REQ_VIEW_PAGER,
116 REQ_ENTER,
117 REQ_QUIT,
118 REQ_PROMPT,
119 REQ_SCREEN_REDRAW,
120 REQ_SCREEN_RESIZE,
121 REQ_SCREEN_UPDATE,
122 REQ_SHOW_VERSION,
123 REQ_STOP_LOADING,
124 REQ_TOGGLE_LINE_NUMBERS,
125 REQ_VIEW_NEXT,
126 REQ_VIEW_CLOSE,
127 REQ_NEXT,
128 REQ_PREVIOUS,
130 REQ_MOVE_UP,
131 REQ_MOVE_DOWN,
132 REQ_MOVE_PAGE_UP,
133 REQ_MOVE_PAGE_DOWN,
134 REQ_MOVE_FIRST_LINE,
135 REQ_MOVE_LAST_LINE,
137 REQ_SCROLL_LINE_UP,
138 REQ_SCROLL_LINE_DOWN,
139 REQ_SCROLL_PAGE_UP,
140 REQ_SCROLL_PAGE_DOWN,
141 };
143 struct ref {
144 char *name; /* Ref name; tag or head names are shortened. */
145 char id[41]; /* Commit SHA1 ID */
146 unsigned int tag:1; /* Is it a tag? */
147 unsigned int next:1; /* For ref lists: are there more refs? */
148 };
150 static struct ref **get_refs(char *id);
152 struct int_map {
153 const char *name;
154 int namelen;
155 int value;
156 };
158 static int
159 set_from_int_map(struct int_map *map, size_t map_size,
160 int *value, const char *name, int namelen)
161 {
163 int i;
165 for (i = 0; i < map_size; i++)
166 if (namelen == map[i].namelen &&
167 !strncasecmp(name, map[i].name, namelen)) {
168 *value = map[i].value;
169 return OK;
170 }
172 return ERR;
173 }
176 /*
177 * String helpers
178 */
180 static inline void
181 string_ncopy(char *dst, const char *src, int dstlen)
182 {
183 strncpy(dst, src, dstlen - 1);
184 dst[dstlen - 1] = 0;
186 }
188 /* Shorthand for safely copying into a fixed buffer. */
189 #define string_copy(dst, src) \
190 string_ncopy(dst, src, sizeof(dst))
192 static char *
193 chomp_string(char *name)
194 {
195 int namelen;
197 while (isspace(*name))
198 name++;
200 namelen = strlen(name) - 1;
201 while (namelen > 0 && isspace(name[namelen]))
202 name[namelen--] = 0;
204 return name;
205 }
208 /* Shell quoting
209 *
210 * NOTE: The following is a slightly modified copy of the git project's shell
211 * quoting routines found in the quote.c file.
212 *
213 * Help to copy the thing properly quoted for the shell safety. any single
214 * quote is replaced with '\'', any exclamation point is replaced with '\!',
215 * and the whole thing is enclosed in a
216 *
217 * E.g.
218 * original sq_quote result
219 * name ==> name ==> 'name'
220 * a b ==> a b ==> 'a b'
221 * a'b ==> a'\''b ==> 'a'\''b'
222 * a!b ==> a'\!'b ==> 'a'\!'b'
223 */
225 static size_t
226 sq_quote(char buf[SIZEOF_CMD], size_t bufsize, const char *src)
227 {
228 char c;
230 #define BUFPUT(x) do { if (bufsize < SIZEOF_CMD) buf[bufsize++] = (x); } while (0)
232 BUFPUT('\'');
233 while ((c = *src++)) {
234 if (c == '\'' || c == '!') {
235 BUFPUT('\'');
236 BUFPUT('\\');
237 BUFPUT(c);
238 BUFPUT('\'');
239 } else {
240 BUFPUT(c);
241 }
242 }
243 BUFPUT('\'');
245 return bufsize;
246 }
249 /**
250 * OPTIONS
251 * -------
252 **/
254 static const char usage[] =
255 VERSION " (" __DATE__ ")\n"
256 "\n"
257 "Usage: tig [options]\n"
258 " or: tig [options] [--] [git log options]\n"
259 " or: tig [options] log [git log options]\n"
260 " or: tig [options] diff [git diff options]\n"
261 " or: tig [options] show [git show options]\n"
262 " or: tig [options] < [git command output]\n"
263 "\n"
264 "Options:\n"
265 " -l Start up in log view\n"
266 " -d Start up in diff view\n"
267 " -n[I], --line-number[=I] Show line numbers with given interval\n"
268 " -b[N], --tab-size[=N] Set number of spaces for tab expansion\n"
269 " -- Mark end of tig options\n"
270 " -v, --version Show version and exit\n"
271 " -h, --help Show help message and exit\n";
273 /* Option and state variables. */
274 static bool opt_line_number = FALSE;
275 static int opt_num_interval = NUMBER_INTERVAL;
276 static int opt_tab_size = TABSIZE;
277 static enum request opt_request = REQ_VIEW_MAIN;
278 static char opt_cmd[SIZEOF_CMD] = "";
279 static char opt_encoding[20] = "";
280 static bool opt_utf8 = TRUE;
281 static FILE *opt_pipe = NULL;
283 /* Returns the index of log or diff command or -1 to exit. */
284 static bool
285 parse_options(int argc, char *argv[])
286 {
287 int i;
289 for (i = 1; i < argc; i++) {
290 char *opt = argv[i];
292 /**
293 * -l::
294 * Start up in log view using the internal log command.
295 **/
296 if (!strcmp(opt, "-l")) {
297 opt_request = REQ_VIEW_LOG;
298 continue;
299 }
301 /**
302 * -d::
303 * Start up in diff view using the internal diff command.
304 **/
305 if (!strcmp(opt, "-d")) {
306 opt_request = REQ_VIEW_DIFF;
307 continue;
308 }
310 /**
311 * -n[INTERVAL], --line-number[=INTERVAL]::
312 * Prefix line numbers in log and diff view.
313 * Optionally, with interval different than each line.
314 **/
315 if (!strncmp(opt, "-n", 2) ||
316 !strncmp(opt, "--line-number", 13)) {
317 char *num = opt;
319 if (opt[1] == 'n') {
320 num = opt + 2;
322 } else if (opt[STRING_SIZE("--line-number")] == '=') {
323 num = opt + STRING_SIZE("--line-number=");
324 }
326 if (isdigit(*num))
327 opt_num_interval = atoi(num);
329 opt_line_number = TRUE;
330 continue;
331 }
333 /**
334 * -b[NSPACES], --tab-size[=NSPACES]::
335 * Set the number of spaces tabs should be expanded to.
336 **/
337 if (!strncmp(opt, "-b", 2) ||
338 !strncmp(opt, "--tab-size", 10)) {
339 char *num = opt;
341 if (opt[1] == 'b') {
342 num = opt + 2;
344 } else if (opt[STRING_SIZE("--tab-size")] == '=') {
345 num = opt + STRING_SIZE("--tab-size=");
346 }
348 if (isdigit(*num))
349 opt_tab_size = MIN(atoi(num), TABSIZE);
350 continue;
351 }
353 /**
354 * -v, --version::
355 * Show version and exit.
356 **/
357 if (!strcmp(opt, "-v") ||
358 !strcmp(opt, "--version")) {
359 printf("tig version %s\n", VERSION);
360 return FALSE;
361 }
363 /**
364 * -h, --help::
365 * Show help message and exit.
366 **/
367 if (!strcmp(opt, "-h") ||
368 !strcmp(opt, "--help")) {
369 printf(usage);
370 return FALSE;
371 }
373 /**
374 * \--::
375 * End of tig(1) options. Useful when specifying command
376 * options for the main view. Example:
377 *
378 * $ tig -- --since=1.month
379 **/
380 if (!strcmp(opt, "--")) {
381 i++;
382 break;
383 }
385 /**
386 * log [git log options]::
387 * Open log view using the given git log options.
388 *
389 * diff [git diff options]::
390 * Open diff view using the given git diff options.
391 *
392 * show [git show options]::
393 * Open diff view using the given git show options.
394 **/
395 if (!strcmp(opt, "log") ||
396 !strcmp(opt, "diff") ||
397 !strcmp(opt, "show")) {
398 opt_request = opt[0] == 'l'
399 ? REQ_VIEW_LOG : REQ_VIEW_DIFF;
400 break;
401 }
403 /**
404 * [git log options]::
405 * tig(1) will stop the option parsing when the first
406 * command line parameter not starting with "-" is
407 * encountered. All options including this one will be
408 * passed to git log when loading the main view.
409 * This makes it possible to say:
410 *
411 * $ tig tag-1.0..HEAD
412 **/
413 if (opt[0] && opt[0] != '-')
414 break;
416 die("unknown command '%s'", opt);
417 }
419 if (!isatty(STDIN_FILENO)) {
420 /**
421 * Pager mode
422 * ~~~~~~~~~~
423 * If stdin is a pipe, any log or diff options will be ignored and the
424 * pager view will be opened loading data from stdin. The pager mode
425 * can be used for colorizing output from various git commands.
426 *
427 * Example on how to colorize the output of git-show(1):
428 *
429 * $ git show | tig
430 **/
431 opt_request = REQ_VIEW_PAGER;
432 opt_pipe = stdin;
434 } else if (i < argc) {
435 size_t buf_size;
437 /**
438 * Git command options
439 * ~~~~~~~~~~~~~~~~~~~
440 * All git command options specified on the command line will
441 * be passed to the given command and all will be shell quoted
442 * before they are passed to the shell.
443 *
444 * NOTE: If you specify options for the main view, you should
445 * not use the `--pretty` option as this option will be set
446 * automatically to the format expected by the main view.
447 *
448 * Example on how to open the log view and show both author and
449 * committer information:
450 *
451 * $ tig log --pretty=fuller
452 *
453 * See the <<refspec, "Specifying revisions">> section below
454 * for an introduction to revision options supported by the git
455 * commands. For details on specific git command options, refer
456 * to the man page of the command in question.
457 **/
459 if (opt_request == REQ_VIEW_MAIN)
460 /* XXX: This is vulnerable to the user overriding
461 * options required for the main view parser. */
462 string_copy(opt_cmd, "git log --stat --pretty=raw");
463 else
464 string_copy(opt_cmd, "git");
465 buf_size = strlen(opt_cmd);
467 while (buf_size < sizeof(opt_cmd) && i < argc) {
468 opt_cmd[buf_size++] = ' ';
469 buf_size = sq_quote(opt_cmd, buf_size, argv[i++]);
470 }
472 if (buf_size >= sizeof(opt_cmd))
473 die("command too long");
475 opt_cmd[buf_size] = 0;
477 }
479 if (*opt_encoding && strcasecmp(opt_encoding, "UTF-8"))
480 opt_utf8 = FALSE;
482 return TRUE;
483 }
486 /**
487 * ENVIRONMENT VARIABLES
488 * ---------------------
489 * Several options related to the interface with git can be configured
490 * via environment options.
491 *
492 * Repository references
493 * ~~~~~~~~~~~~~~~~~~~~~
494 * Commits that are referenced by tags and branch heads will be marked
495 * by the reference name surrounded by '[' and ']':
496 *
497 * 2006-03-26 19:42 Petr Baudis | [cogito-0.17.1] Cogito 0.17.1
498 *
499 * If you want to filter out certain directories under `.git/refs/`, say
500 * `tmp` you can do it by setting the following variable:
501 *
502 * $ TIG_LS_REMOTE="git ls-remote . | sed /\/tmp\//d" tig
503 *
504 * Or set the variable permanently in your environment.
505 *
506 * TIG_LS_REMOTE::
507 * Set command for retrieving all repository references. The command
508 * should output data in the same format as git-ls-remote(1).
509 **/
511 #define TIG_LS_REMOTE \
512 "git ls-remote . 2>/dev/null"
514 /**
515 * [[history-commands]]
516 * History commands
517 * ~~~~~~~~~~~~~~~~
518 * It is possible to alter which commands are used for the different views.
519 * If for example you prefer commits in the main view to be sorted by date
520 * and only show 500 commits, use:
521 *
522 * $ TIG_MAIN_CMD="git log --date-order -n500 --pretty=raw %s" tig
523 *
524 * Or set the variable permanently in your environment.
525 *
526 * Notice, how `%s` is used to specify the commit reference. There can
527 * be a maximum of 5 `%s` ref specifications.
528 *
529 * TIG_DIFF_CMD::
530 * The command used for the diff view. By default, git show is used
531 * as a backend.
532 *
533 * TIG_LOG_CMD::
534 * The command used for the log view. If you prefer to have both
535 * author and committer shown in the log view be sure to pass
536 * `--pretty=fuller` to git log.
537 *
538 * TIG_MAIN_CMD::
539 * The command used for the main view. Note, you must always specify
540 * the option: `--pretty=raw` since the main view parser expects to
541 * read that format.
542 **/
544 #define TIG_DIFF_CMD \
545 "git show --patch-with-stat --find-copies-harder -B -C %s"
547 #define TIG_LOG_CMD \
548 "git log --cc --stat -n100 %s"
550 #define TIG_MAIN_CMD \
551 "git log --topo-order --stat --pretty=raw %s"
553 /* ... silently ignore that the following are also exported. */
555 #define TIG_HELP_CMD \
556 "man tig 2>/dev/null"
558 #define TIG_PAGER_CMD \
559 ""
562 /**
563 * FILES
564 * -----
565 * '~/.tigrc'::
566 * User configuration file. See tigrc(5) for examples.
567 *
568 * '.git/config'::
569 * Repository config file. Read on startup with the help of
570 * git-repo-config(1).
571 **/
573 static struct int_map color_map[] = {
574 #define COLOR_MAP(name) { #name, STRING_SIZE(#name), COLOR_##name }
575 COLOR_MAP(DEFAULT),
576 COLOR_MAP(BLACK),
577 COLOR_MAP(BLUE),
578 COLOR_MAP(CYAN),
579 COLOR_MAP(GREEN),
580 COLOR_MAP(MAGENTA),
581 COLOR_MAP(RED),
582 COLOR_MAP(WHITE),
583 COLOR_MAP(YELLOW),
584 };
586 static struct int_map attr_map[] = {
587 #define ATTR_MAP(name) { #name, STRING_SIZE(#name), A_##name }
588 ATTR_MAP(NORMAL),
589 ATTR_MAP(BLINK),
590 ATTR_MAP(BOLD),
591 ATTR_MAP(DIM),
592 ATTR_MAP(REVERSE),
593 ATTR_MAP(STANDOUT),
594 ATTR_MAP(UNDERLINE),
595 };
597 #define LINE_INFO \
598 LINE(DIFF_HEADER, "diff --git ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
599 LINE(DIFF_CHUNK, "@@", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
600 LINE(DIFF_ADD, "+", COLOR_GREEN, COLOR_DEFAULT, 0), \
601 LINE(DIFF_DEL, "-", COLOR_RED, COLOR_DEFAULT, 0), \
602 LINE(DIFF_INDEX, "index ", COLOR_BLUE, COLOR_DEFAULT, 0), \
603 LINE(DIFF_OLDMODE, "old file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
604 LINE(DIFF_NEWMODE, "new file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
605 LINE(DIFF_COPY_FROM, "copy from", COLOR_YELLOW, COLOR_DEFAULT, 0), \
606 LINE(DIFF_COPY_TO, "copy to", COLOR_YELLOW, COLOR_DEFAULT, 0), \
607 LINE(DIFF_RENAME_FROM, "rename from", COLOR_YELLOW, COLOR_DEFAULT, 0), \
608 LINE(DIFF_RENAME_TO, "rename to", COLOR_YELLOW, COLOR_DEFAULT, 0), \
609 LINE(DIFF_SIMILARITY, "similarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
610 LINE(DIFF_DISSIMILARITY,"dissimilarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
611 LINE(DIFF_TREE, "diff-tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
612 LINE(PP_AUTHOR, "Author: ", COLOR_CYAN, COLOR_DEFAULT, 0), \
613 LINE(PP_COMMIT, "Commit: ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
614 LINE(PP_MERGE, "Merge: ", COLOR_BLUE, COLOR_DEFAULT, 0), \
615 LINE(PP_DATE, "Date: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
616 LINE(PP_ADATE, "AuthorDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
617 LINE(PP_CDATE, "CommitDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
618 LINE(COMMIT, "commit ", COLOR_GREEN, COLOR_DEFAULT, 0), \
619 LINE(PARENT, "parent ", COLOR_BLUE, COLOR_DEFAULT, 0), \
620 LINE(TREE, "tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
621 LINE(AUTHOR, "author ", COLOR_CYAN, COLOR_DEFAULT, 0), \
622 LINE(COMMITTER, "committer ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
623 LINE(SIGNOFF, " Signed-off-by", COLOR_YELLOW, COLOR_DEFAULT, 0), \
624 LINE(DEFAULT, "", COLOR_DEFAULT, COLOR_DEFAULT, A_NORMAL), \
625 LINE(CURSOR, "", COLOR_WHITE, COLOR_GREEN, A_BOLD), \
626 LINE(STATUS, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
627 LINE(TITLE_BLUR, "", COLOR_WHITE, COLOR_BLUE, 0), \
628 LINE(TITLE_FOCUS, "", COLOR_WHITE, COLOR_BLUE, A_BOLD), \
629 LINE(MAIN_DATE, "", COLOR_BLUE, COLOR_DEFAULT, 0), \
630 LINE(MAIN_AUTHOR, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
631 LINE(MAIN_COMMIT, "", COLOR_DEFAULT, COLOR_DEFAULT, 0), \
632 LINE(MAIN_DELIM, "", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
633 LINE(MAIN_TAG, "", COLOR_MAGENTA, COLOR_DEFAULT, A_BOLD), \
634 LINE(MAIN_REF, "", COLOR_CYAN, COLOR_DEFAULT, A_BOLD), \
637 /*
638 * Line-oriented content detection.
639 */
641 enum line_type {
642 #define LINE(type, line, fg, bg, attr) \
643 LINE_##type
644 LINE_INFO
645 #undef LINE
646 };
648 struct line_info {
649 const char *name; /* Option name. */
650 int namelen; /* Size of option name. */
651 const char *line; /* The start of line to match. */
652 int linelen; /* Size of string to match. */
653 int fg, bg, attr; /* Color and text attributes for the lines. */
654 };
656 static struct line_info line_info[] = {
657 #define LINE(type, line, fg, bg, attr) \
658 { #type, STRING_SIZE(#type), (line), STRING_SIZE(line), (fg), (bg), (attr) }
659 LINE_INFO
660 #undef LINE
661 };
663 static enum line_type
664 get_line_type(char *line)
665 {
666 int linelen = strlen(line);
667 enum line_type type;
669 for (type = 0; type < ARRAY_SIZE(line_info); type++)
670 /* Case insensitive search matches Signed-off-by lines better. */
671 if (linelen >= line_info[type].linelen &&
672 !strncasecmp(line_info[type].line, line, line_info[type].linelen))
673 return type;
675 return LINE_DEFAULT;
676 }
678 static inline int
679 get_line_attr(enum line_type type)
680 {
681 assert(type < ARRAY_SIZE(line_info));
682 return COLOR_PAIR(type) | line_info[type].attr;
683 }
685 static struct line_info *
686 get_line_info(char *name, int namelen)
687 {
688 enum line_type type;
689 int i;
691 /* Diff-Header -> DIFF_HEADER */
692 for (i = 0; i < namelen; i++) {
693 if (name[i] == '-')
694 name[i] = '_';
695 else if (name[i] == '.')
696 name[i] = '_';
697 }
699 for (type = 0; type < ARRAY_SIZE(line_info); type++)
700 if (namelen == line_info[type].namelen &&
701 !strncasecmp(line_info[type].name, name, namelen))
702 return &line_info[type];
704 return NULL;
705 }
707 static void
708 init_colors(void)
709 {
710 int default_bg = COLOR_BLACK;
711 int default_fg = COLOR_WHITE;
712 enum line_type type;
714 start_color();
716 if (use_default_colors() != ERR) {
717 default_bg = -1;
718 default_fg = -1;
719 }
721 for (type = 0; type < ARRAY_SIZE(line_info); type++) {
722 struct line_info *info = &line_info[type];
723 int bg = info->bg == COLOR_DEFAULT ? default_bg : info->bg;
724 int fg = info->fg == COLOR_DEFAULT ? default_fg : info->fg;
726 init_pair(type, fg, bg);
727 }
728 }
730 struct line {
731 enum line_type type;
732 void *data; /* User data */
733 };
736 /*
737 * User config file handling.
738 */
740 #define set_color(color, name, namelen) \
741 set_from_int_map(color_map, ARRAY_SIZE(color_map), color, name, namelen)
743 #define set_attribute(attr, name, namelen) \
744 set_from_int_map(attr_map, ARRAY_SIZE(attr_map), attr, name, namelen)
746 static int config_lineno;
747 static bool config_errors;
748 static char *config_msg;
750 static int
751 set_option(char *opt, int optlen, char *value, int valuelen)
752 {
753 /* Reads: "color" object fgcolor bgcolor [attr] */
754 if (!strcmp(opt, "color")) {
755 struct line_info *info;
757 value = chomp_string(value);
758 valuelen = strcspn(value, " \t");
759 info = get_line_info(value, valuelen);
760 if (!info) {
761 config_msg = "Unknown color name";
762 return ERR;
763 }
765 value = chomp_string(value + valuelen);
766 valuelen = strcspn(value, " \t");
767 if (set_color(&info->fg, value, valuelen) == ERR) {
768 config_msg = "Unknown color";
769 return ERR;
770 }
772 value = chomp_string(value + valuelen);
773 valuelen = strcspn(value, " \t");
774 if (set_color(&info->bg, value, valuelen) == ERR) {
775 config_msg = "Unknown color";
776 return ERR;
777 }
779 value = chomp_string(value + valuelen);
780 if (*value &&
781 set_attribute(&info->attr, value, strlen(value)) == ERR) {
782 config_msg = "Unknown attribute";
783 return ERR;
784 }
786 return OK;
787 }
789 return ERR;
790 }
792 static int
793 read_option(char *opt, int optlen, char *value, int valuelen)
794 {
795 config_lineno++;
796 config_msg = "Internal error";
798 optlen = strcspn(opt, "#;");
799 if (optlen == 0) {
800 /* The whole line is a commend or empty. */
801 return OK;
803 } else if (opt[optlen] != 0) {
804 /* Part of the option name is a comment, so the value part
805 * should be ignored. */
806 valuelen = 0;
807 opt[optlen] = value[valuelen] = 0;
808 } else {
809 /* Else look for comment endings in the value. */
810 valuelen = strcspn(value, "#;");
811 value[valuelen] = 0;
812 }
814 if (set_option(opt, optlen, value, valuelen) == ERR) {
815 fprintf(stderr, "Error on line %d, near '%.*s' option: %s\n",
816 config_lineno, optlen, opt, config_msg);
817 config_errors = TRUE;
818 }
820 /* Always keep going if errors are encountered. */
821 return OK;
822 }
824 static int
825 load_options(void)
826 {
827 char *home = getenv("HOME");
828 char buf[1024];
829 FILE *file;
831 config_lineno = 0;
832 config_errors = FALSE;
834 if (!home ||
835 snprintf(buf, sizeof(buf), "%s/.tigrc", home) >= sizeof(buf))
836 return ERR;
838 /* It's ok that the file doesn't exist. */
839 file = fopen(buf, "r");
840 if (!file)
841 return OK;
843 if (read_properties(file, " \t", read_option) == ERR ||
844 config_errors == TRUE)
845 fprintf(stderr, "Errors while loading %s.\n", buf);
847 return OK;
848 }
851 /**
852 * The viewer
853 * ----------
854 * The display consists of a status window on the last line of the screen and
855 * one or more views. The default is to only show one view at the time but it
856 * is possible to split both the main and log view to also show the commit
857 * diff.
858 *
859 * If you are in the log view and press 'Enter' when the current line is a
860 * commit line, such as:
861 *
862 * commit 4d55caff4cc89335192f3e566004b4ceef572521
863 *
864 * You will split the view so that the log view is displayed in the top window
865 * and the diff view in the bottom window. You can switch between the two
866 * views by pressing 'Tab'. To maximize the log view again, simply press 'l'.
867 **/
869 struct view;
870 struct view_ops;
872 /* The display array of active views and the index of the current view. */
873 static struct view *display[2];
874 static unsigned int current_view;
876 #define foreach_view(view, i) \
877 for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
879 #define displayed_views() (display[1] != NULL ? 2 : 1)
881 /**
882 * Current head and commit ID
883 * ~~~~~~~~~~~~~~~~~~~~~~~~~~
884 * The viewer keeps track of both what head and commit ID you are currently
885 * viewing. The commit ID will follow the cursor line and change everytime time
886 * you highlight a different commit. Whenever you reopen the diff view it
887 * will be reloaded, if the commit ID changed.
888 *
889 * The head ID is used when opening the main and log view to indicate from
890 * what revision to show history.
891 **/
893 static char ref_commit[SIZEOF_REF] = "HEAD";
894 static char ref_head[SIZEOF_REF] = "HEAD";
896 struct view {
897 const char *name; /* View name */
898 const char *cmd_fmt; /* Default command line format */
899 const char *cmd_env; /* Command line set via environment */
900 const char *id; /* Points to either of ref_{head,commit} */
902 struct view_ops *ops; /* View operations */
904 char cmd[SIZEOF_CMD]; /* Command buffer */
905 char ref[SIZEOF_REF]; /* Hovered commit reference */
906 char vid[SIZEOF_REF]; /* View ID. Set to id member when updating. */
908 int height, width; /* The width and height of the main window */
909 WINDOW *win; /* The main window */
910 WINDOW *title; /* The title window living below the main window */
912 /* Navigation */
913 unsigned long offset; /* Offset of the window top */
914 unsigned long lineno; /* Current line number */
916 /* If non-NULL, points to the view that opened this view. If this view
917 * is closed tig will switch back to the parent view. */
918 struct view *parent;
920 /* Buffering */
921 unsigned long lines; /* Total number of lines */
922 struct line *line; /* Line index */
923 unsigned int digits; /* Number of digits in the lines member. */
925 /* Loading */
926 FILE *pipe;
927 time_t start_time;
928 };
930 struct view_ops {
931 /* What type of content being displayed. Used in the title bar. */
932 const char *type;
933 /* Draw one line; @lineno must be < view->height. */
934 bool (*draw)(struct view *view, struct line *line, unsigned int lineno);
935 /* Read one line; updates view->line. */
936 bool (*read)(struct view *view, struct line *prev, char *data);
937 /* Depending on view, change display based on current line. */
938 bool (*enter)(struct view *view, struct line *line);
939 };
941 static struct view_ops pager_ops;
942 static struct view_ops main_ops;
944 #define VIEW_STR(name, cmd, env, ref, ops) \
945 { name, cmd, #env, ref, ops }
947 #define VIEW_(id, name, ops, ref) \
948 VIEW_STR(name, TIG_##id##_CMD, TIG_##id##_CMD, ref, ops)
950 /**
951 * Views
952 * ~~~~~
953 * tig(1) presents various 'views' of a repository. Each view is based on output
954 * from an external command, most often 'git log', 'git diff', or 'git show'.
955 *
956 * The main view::
957 * Is the default view, and it shows a one line summary of each commit
958 * in the chosen list of revisions. The summary includes commit date,
959 * author, and the first line of the log message. Additionally, any
960 * repository references, such as tags, will be shown.
961 *
962 * The log view::
963 * Presents a more rich view of the revision log showing the whole log
964 * message and the diffstat.
965 *
966 * The diff view::
967 * Shows either the diff of the current working tree, that is, what
968 * has changed since the last commit, or the commit diff complete
969 * with log message, diffstat and diff.
970 *
971 * The pager view::
972 * Is used for displaying both input from stdin and output from git
973 * commands entered in the internal prompt.
974 *
975 * The help view::
976 * Displays the information from the tig(1) man page. For the help view
977 * to work you need to have the tig(1) man page installed.
978 **/
980 static struct view views[] = {
981 VIEW_(MAIN, "main", &main_ops, ref_head),
982 VIEW_(DIFF, "diff", &pager_ops, ref_commit),
983 VIEW_(LOG, "log", &pager_ops, ref_head),
984 VIEW_(HELP, "help", &pager_ops, "static"),
985 VIEW_(PAGER, "pager", &pager_ops, "static"),
986 };
988 #define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
991 static bool
992 draw_view_line(struct view *view, unsigned int lineno)
993 {
994 if (view->offset + lineno >= view->lines)
995 return FALSE;
997 return view->ops->draw(view, &view->line[view->offset + lineno], lineno);
998 }
1000 static void
1001 redraw_view_from(struct view *view, int lineno)
1002 {
1003 assert(0 <= lineno && lineno < view->height);
1005 for (; lineno < view->height; lineno++) {
1006 if (!draw_view_line(view, lineno))
1007 break;
1008 }
1010 redrawwin(view->win);
1011 wrefresh(view->win);
1012 }
1014 static void
1015 redraw_view(struct view *view)
1016 {
1017 wclear(view->win);
1018 redraw_view_from(view, 0);
1019 }
1022 /**
1023 * Title windows
1024 * ~~~~~~~~~~~~~
1025 * Each view has a title window which shows the name of the view, current
1026 * commit ID if available, and where the view is positioned:
1027 *
1028 * [main] c622eefaa485995320bc743431bae0d497b1d875 - commit 1 of 61 (1%)
1029 *
1030 * By default, the title of the current view is highlighted using bold font.
1031 * For long loading views (taking over 3 seconds) the time since loading
1032 * started will be appended:
1033 *
1034 * [main] 77d9e40fbcea3238015aea403e06f61542df9a31 - commit 1 of 779 (0%) 5s
1035 **/
1037 static void
1038 update_view_title(struct view *view)
1039 {
1040 if (view == display[current_view])
1041 wbkgdset(view->title, get_line_attr(LINE_TITLE_FOCUS));
1042 else
1043 wbkgdset(view->title, get_line_attr(LINE_TITLE_BLUR));
1045 werase(view->title);
1046 wmove(view->title, 0, 0);
1048 if (*view->ref)
1049 wprintw(view->title, "[%s] %s", view->name, view->ref);
1050 else
1051 wprintw(view->title, "[%s]", view->name);
1053 if (view->lines || view->pipe) {
1054 unsigned int lines = view->lines
1055 ? (view->lineno + 1) * 100 / view->lines
1056 : 0;
1058 wprintw(view->title, " - %s %d of %d (%d%%)",
1059 view->ops->type,
1060 view->lineno + 1,
1061 view->lines,
1062 lines);
1063 }
1065 if (view->pipe) {
1066 time_t secs = time(NULL) - view->start_time;
1068 /* Three git seconds are a long time ... */
1069 if (secs > 2)
1070 wprintw(view->title, " %lds", secs);
1071 }
1073 wmove(view->title, 0, view->width - 1);
1074 wrefresh(view->title);
1075 }
1077 static void
1078 resize_display(void)
1079 {
1080 int offset, i;
1081 struct view *base = display[0];
1082 struct view *view = display[1] ? display[1] : display[0];
1084 /* Setup window dimensions */
1086 getmaxyx(stdscr, base->height, base->width);
1088 /* Make room for the status window. */
1089 base->height -= 1;
1091 if (view != base) {
1092 /* Horizontal split. */
1093 view->width = base->width;
1094 view->height = SCALE_SPLIT_VIEW(base->height);
1095 base->height -= view->height;
1097 /* Make room for the title bar. */
1098 view->height -= 1;
1099 }
1101 /* Make room for the title bar. */
1102 base->height -= 1;
1104 offset = 0;
1106 foreach_view (view, i) {
1107 if (!view->win) {
1108 view->win = newwin(view->height, 0, offset, 0);
1109 if (!view->win)
1110 die("Failed to create %s view", view->name);
1112 scrollok(view->win, TRUE);
1114 view->title = newwin(1, 0, offset + view->height, 0);
1115 if (!view->title)
1116 die("Failed to create title window");
1118 } else {
1119 wresize(view->win, view->height, view->width);
1120 mvwin(view->win, offset, 0);
1121 mvwin(view->title, offset + view->height, 0);
1122 }
1124 offset += view->height + 1;
1125 }
1126 }
1128 static void
1129 redraw_display(void)
1130 {
1131 struct view *view;
1132 int i;
1134 foreach_view (view, i) {
1135 redraw_view(view);
1136 update_view_title(view);
1137 }
1138 }
1140 static void
1141 update_display_cursor(void)
1142 {
1143 struct view *view = display[current_view];
1145 /* Move the cursor to the right-most column of the cursor line.
1146 *
1147 * XXX: This could turn out to be a bit expensive, but it ensures that
1148 * the cursor does not jump around. */
1149 if (view->lines) {
1150 wmove(view->win, view->lineno - view->offset, view->width - 1);
1151 wrefresh(view->win);
1152 }
1153 }
1155 /*
1156 * Navigation
1157 */
1159 /* Scrolling backend */
1160 static void
1161 do_scroll_view(struct view *view, int lines, bool redraw)
1162 {
1163 /* The rendering expects the new offset. */
1164 view->offset += lines;
1166 assert(0 <= view->offset && view->offset < view->lines);
1167 assert(lines);
1169 /* Redraw the whole screen if scrolling is pointless. */
1170 if (view->height < ABS(lines)) {
1171 redraw_view(view);
1173 } else {
1174 int line = lines > 0 ? view->height - lines : 0;
1175 int end = line + ABS(lines);
1177 wscrl(view->win, lines);
1179 for (; line < end; line++) {
1180 if (!draw_view_line(view, line))
1181 break;
1182 }
1183 }
1185 /* Move current line into the view. */
1186 if (view->lineno < view->offset) {
1187 view->lineno = view->offset;
1188 draw_view_line(view, 0);
1190 } else if (view->lineno >= view->offset + view->height) {
1191 if (view->lineno == view->offset + view->height) {
1192 /* Clear the hidden line so it doesn't show if the view
1193 * is scrolled up. */
1194 wmove(view->win, view->height, 0);
1195 wclrtoeol(view->win);
1196 }
1197 view->lineno = view->offset + view->height - 1;
1198 draw_view_line(view, view->lineno - view->offset);
1199 }
1201 assert(view->offset <= view->lineno && view->lineno < view->lines);
1203 if (!redraw)
1204 return;
1206 redrawwin(view->win);
1207 wrefresh(view->win);
1208 report("");
1209 }
1211 /* Scroll frontend */
1212 static void
1213 scroll_view(struct view *view, enum request request)
1214 {
1215 int lines = 1;
1217 switch (request) {
1218 case REQ_SCROLL_PAGE_DOWN:
1219 lines = view->height;
1220 case REQ_SCROLL_LINE_DOWN:
1221 if (view->offset + lines > view->lines)
1222 lines = view->lines - view->offset;
1224 if (lines == 0 || view->offset + view->height >= view->lines) {
1225 report("Cannot scroll beyond the last line");
1226 return;
1227 }
1228 break;
1230 case REQ_SCROLL_PAGE_UP:
1231 lines = view->height;
1232 case REQ_SCROLL_LINE_UP:
1233 if (lines > view->offset)
1234 lines = view->offset;
1236 if (lines == 0) {
1237 report("Cannot scroll beyond the first line");
1238 return;
1239 }
1241 lines = -lines;
1242 break;
1244 default:
1245 die("request %d not handled in switch", request);
1246 }
1248 do_scroll_view(view, lines, TRUE);
1249 }
1251 /* Cursor moving */
1252 static void
1253 move_view(struct view *view, enum request request, bool redraw)
1254 {
1255 int steps;
1257 switch (request) {
1258 case REQ_MOVE_FIRST_LINE:
1259 steps = -view->lineno;
1260 break;
1262 case REQ_MOVE_LAST_LINE:
1263 steps = view->lines - view->lineno - 1;
1264 break;
1266 case REQ_MOVE_PAGE_UP:
1267 steps = view->height > view->lineno
1268 ? -view->lineno : -view->height;
1269 break;
1271 case REQ_MOVE_PAGE_DOWN:
1272 steps = view->lineno + view->height >= view->lines
1273 ? view->lines - view->lineno - 1 : view->height;
1274 break;
1276 case REQ_MOVE_UP:
1277 steps = -1;
1278 break;
1280 case REQ_MOVE_DOWN:
1281 steps = 1;
1282 break;
1284 default:
1285 die("request %d not handled in switch", request);
1286 }
1288 if (steps <= 0 && view->lineno == 0) {
1289 report("Cannot move beyond the first line");
1290 return;
1292 } else if (steps >= 0 && view->lineno + 1 >= view->lines) {
1293 report("Cannot move beyond the last line");
1294 return;
1295 }
1297 /* Move the current line */
1298 view->lineno += steps;
1299 assert(0 <= view->lineno && view->lineno < view->lines);
1301 /* Repaint the old "current" line if we be scrolling */
1302 if (ABS(steps) < view->height) {
1303 int prev_lineno = view->lineno - steps - view->offset;
1305 wmove(view->win, prev_lineno, 0);
1306 wclrtoeol(view->win);
1307 draw_view_line(view, prev_lineno);
1308 }
1310 /* Check whether the view needs to be scrolled */
1311 if (view->lineno < view->offset ||
1312 view->lineno >= view->offset + view->height) {
1313 if (steps < 0 && -steps > view->offset) {
1314 steps = -view->offset;
1316 } else if (steps > 0) {
1317 if (view->lineno == view->lines - 1 &&
1318 view->lines > view->height) {
1319 steps = view->lines - view->offset - 1;
1320 if (steps >= view->height)
1321 steps -= view->height - 1;
1322 }
1323 }
1325 do_scroll_view(view, steps, redraw);
1326 return;
1327 }
1329 /* Draw the current line */
1330 draw_view_line(view, view->lineno - view->offset);
1332 if (!redraw)
1333 return;
1335 redrawwin(view->win);
1336 wrefresh(view->win);
1337 report("");
1338 }
1341 /*
1342 * Incremental updating
1343 */
1345 static void
1346 end_update(struct view *view)
1347 {
1348 if (!view->pipe)
1349 return;
1350 set_nonblocking_input(FALSE);
1351 if (view->pipe == stdin)
1352 fclose(view->pipe);
1353 else
1354 pclose(view->pipe);
1355 view->pipe = NULL;
1356 }
1358 static bool
1359 begin_update(struct view *view)
1360 {
1361 const char *id = view->id;
1363 if (view->pipe)
1364 end_update(view);
1366 if (opt_cmd[0]) {
1367 string_copy(view->cmd, opt_cmd);
1368 opt_cmd[0] = 0;
1369 /* When running random commands, the view ref could have become
1370 * invalid so clear it. */
1371 view->ref[0] = 0;
1372 } else {
1373 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
1375 if (snprintf(view->cmd, sizeof(view->cmd), format,
1376 id, id, id, id, id) >= sizeof(view->cmd))
1377 return FALSE;
1378 }
1380 /* Special case for the pager view. */
1381 if (opt_pipe) {
1382 view->pipe = opt_pipe;
1383 opt_pipe = NULL;
1384 } else {
1385 view->pipe = popen(view->cmd, "r");
1386 }
1388 if (!view->pipe)
1389 return FALSE;
1391 set_nonblocking_input(TRUE);
1393 view->offset = 0;
1394 view->lines = 0;
1395 view->lineno = 0;
1396 string_copy(view->vid, id);
1398 if (view->line) {
1399 int i;
1401 for (i = 0; i < view->lines; i++)
1402 if (view->line[i].data)
1403 free(view->line[i].data);
1405 free(view->line);
1406 view->line = NULL;
1407 }
1409 view->start_time = time(NULL);
1411 return TRUE;
1412 }
1414 static bool
1415 update_view(struct view *view)
1416 {
1417 char buffer[BUFSIZ];
1418 char *line;
1419 struct line *tmp;
1420 /* The number of lines to read. If too low it will cause too much
1421 * redrawing (and possible flickering), if too high responsiveness
1422 * will suffer. */
1423 unsigned long lines = view->height;
1424 int redraw_from = -1;
1426 if (!view->pipe)
1427 return TRUE;
1429 /* Only redraw if lines are visible. */
1430 if (view->offset + view->height >= view->lines)
1431 redraw_from = view->lines - view->offset;
1433 tmp = realloc(view->line, sizeof(*view->line) * (view->lines + lines));
1434 if (!tmp)
1435 goto alloc_error;
1437 view->line = tmp;
1439 while ((line = fgets(buffer, sizeof(buffer), view->pipe))) {
1440 int linelen = strlen(line);
1442 struct line *prev = view->lines
1443 ? &view->line[view->lines - 1]
1444 : NULL;
1446 if (linelen)
1447 line[linelen - 1] = 0;
1449 if (!view->ops->read(view, prev, line))
1450 goto alloc_error;
1452 if (lines-- == 1)
1453 break;
1454 }
1456 {
1457 int digits;
1459 lines = view->lines;
1460 for (digits = 0; lines; digits++)
1461 lines /= 10;
1463 /* Keep the displayed view in sync with line number scaling. */
1464 if (digits != view->digits) {
1465 view->digits = digits;
1466 redraw_from = 0;
1467 }
1468 }
1470 if (redraw_from >= 0) {
1471 /* If this is an incremental update, redraw the previous line
1472 * since for commits some members could have changed when
1473 * loading the main view. */
1474 if (redraw_from > 0)
1475 redraw_from--;
1477 /* Incrementally draw avoids flickering. */
1478 redraw_view_from(view, redraw_from);
1479 }
1481 /* Update the title _after_ the redraw so that if the redraw picks up a
1482 * commit reference in view->ref it'll be available here. */
1483 update_view_title(view);
1485 if (ferror(view->pipe)) {
1486 report("Failed to read: %s", strerror(errno));
1487 goto end;
1489 } else if (feof(view->pipe)) {
1490 if (view == VIEW(REQ_VIEW_HELP)) {
1491 const char *msg = TIG_HELP;
1493 if (view->lines == 0) {
1494 /* Slightly ugly, but abusing view->ref keeps
1495 * the error message. */
1496 string_copy(view->ref, "No help available");
1497 msg = "The tig(1) manpage is not installed";
1498 }
1500 report("%s", msg);
1501 goto end;
1502 }
1504 report("");
1505 goto end;
1506 }
1508 return TRUE;
1510 alloc_error:
1511 report("Allocation failure");
1513 end:
1514 end_update(view);
1515 return FALSE;
1516 }
1518 enum open_flags {
1519 OPEN_DEFAULT = 0, /* Use default view switching. */
1520 OPEN_SPLIT = 1, /* Split current view. */
1521 OPEN_BACKGROUNDED = 2, /* Backgrounded. */
1522 OPEN_RELOAD = 4, /* Reload view even if it is the current. */
1523 };
1525 static void
1526 open_view(struct view *prev, enum request request, enum open_flags flags)
1527 {
1528 bool backgrounded = !!(flags & OPEN_BACKGROUNDED);
1529 bool split = !!(flags & OPEN_SPLIT);
1530 bool reload = !!(flags & OPEN_RELOAD);
1531 struct view *view = VIEW(request);
1532 int nviews = displayed_views();
1533 struct view *base_view = display[0];
1535 if (view == prev && nviews == 1 && !reload) {
1536 report("Already in %s view", view->name);
1537 return;
1538 }
1540 if ((reload || strcmp(view->vid, view->id)) &&
1541 !begin_update(view)) {
1542 report("Failed to load %s view", view->name);
1543 return;
1544 }
1546 if (split) {
1547 display[current_view + 1] = view;
1548 if (!backgrounded)
1549 current_view++;
1550 } else {
1551 /* Maximize the current view. */
1552 memset(display, 0, sizeof(display));
1553 current_view = 0;
1554 display[current_view] = view;
1555 }
1557 /* Resize the view when switching between split- and full-screen,
1558 * or when switching between two different full-screen views. */
1559 if (nviews != displayed_views() ||
1560 (nviews == 1 && base_view != display[0]))
1561 resize_display();
1563 if (split && prev->lineno - prev->offset >= prev->height) {
1564 /* Take the title line into account. */
1565 int lines = prev->lineno - prev->offset - prev->height + 1;
1567 /* Scroll the view that was split if the current line is
1568 * outside the new limited view. */
1569 do_scroll_view(prev, lines, TRUE);
1570 }
1572 if (prev && view != prev) {
1573 if (split && !backgrounded) {
1574 /* "Blur" the previous view. */
1575 update_view_title(prev);
1576 }
1578 view->parent = prev;
1579 }
1581 if (view->pipe && view->lines == 0) {
1582 /* Clear the old view and let the incremental updating refill
1583 * the screen. */
1584 wclear(view->win);
1585 report("");
1586 } else {
1587 redraw_view(view);
1588 if (view == VIEW(REQ_VIEW_HELP))
1589 report("%s", TIG_HELP);
1590 else
1591 report("");
1592 }
1594 /* If the view is backgrounded the above calls to report()
1595 * won't redraw the view title. */
1596 if (backgrounded)
1597 update_view_title(view);
1598 }
1601 /*
1602 * User request switch noodle
1603 */
1605 static int
1606 view_driver(struct view *view, enum request request)
1607 {
1608 int i;
1610 switch (request) {
1611 case REQ_MOVE_UP:
1612 case REQ_MOVE_DOWN:
1613 case REQ_MOVE_PAGE_UP:
1614 case REQ_MOVE_PAGE_DOWN:
1615 case REQ_MOVE_FIRST_LINE:
1616 case REQ_MOVE_LAST_LINE:
1617 move_view(view, request, TRUE);
1618 break;
1620 case REQ_SCROLL_LINE_DOWN:
1621 case REQ_SCROLL_LINE_UP:
1622 case REQ_SCROLL_PAGE_DOWN:
1623 case REQ_SCROLL_PAGE_UP:
1624 scroll_view(view, request);
1625 break;
1627 case REQ_VIEW_MAIN:
1628 case REQ_VIEW_DIFF:
1629 case REQ_VIEW_LOG:
1630 case REQ_VIEW_HELP:
1631 case REQ_VIEW_PAGER:
1632 open_view(view, request, OPEN_DEFAULT);
1633 break;
1635 case REQ_NEXT:
1636 case REQ_PREVIOUS:
1637 request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
1639 if (view == VIEW(REQ_VIEW_DIFF) &&
1640 view->parent == VIEW(REQ_VIEW_MAIN)) {
1641 bool redraw = display[1] == view;
1643 view = view->parent;
1644 move_view(view, request, redraw);
1645 if (redraw)
1646 update_view_title(view);
1647 } else {
1648 move_view(view, request, TRUE);
1649 break;
1650 }
1651 /* Fall-through */
1653 case REQ_ENTER:
1654 if (!view->lines) {
1655 report("Nothing to enter");
1656 break;
1657 }
1658 return view->ops->enter(view, &view->line[view->lineno]);
1660 case REQ_VIEW_NEXT:
1661 {
1662 int nviews = displayed_views();
1663 int next_view = (current_view + 1) % nviews;
1665 if (next_view == current_view) {
1666 report("Only one view is displayed");
1667 break;
1668 }
1670 current_view = next_view;
1671 /* Blur out the title of the previous view. */
1672 update_view_title(view);
1673 report("");
1674 break;
1675 }
1676 case REQ_TOGGLE_LINE_NUMBERS:
1677 opt_line_number = !opt_line_number;
1678 redraw_display();
1679 break;
1681 case REQ_PROMPT:
1682 /* Always reload^Wrerun commands from the prompt. */
1683 open_view(view, opt_request, OPEN_RELOAD);
1684 break;
1686 case REQ_STOP_LOADING:
1687 for (i = 0; i < ARRAY_SIZE(views); i++) {
1688 view = &views[i];
1689 if (view->pipe)
1690 report("Stopped loading the %s view", view->name),
1691 end_update(view);
1692 }
1693 break;
1695 case REQ_SHOW_VERSION:
1696 report("%s (built %s)", VERSION, __DATE__);
1697 return TRUE;
1699 case REQ_SCREEN_RESIZE:
1700 resize_display();
1701 /* Fall-through */
1702 case REQ_SCREEN_REDRAW:
1703 redraw_display();
1704 break;
1706 case REQ_SCREEN_UPDATE:
1707 doupdate();
1708 return TRUE;
1710 case REQ_VIEW_CLOSE:
1711 /* XXX: Mark closed views by letting view->parent point to the
1712 * view itself. Parents to closed view should never be
1713 * followed. */
1714 if (view->parent &&
1715 view->parent->parent != view->parent) {
1716 memset(display, 0, sizeof(display));
1717 current_view = 0;
1718 display[current_view] = view->parent;
1719 view->parent = view;
1720 resize_display();
1721 redraw_display();
1722 break;
1723 }
1724 /* Fall-through */
1725 case REQ_QUIT:
1726 return FALSE;
1728 default:
1729 /* An unknown key will show most commonly used commands. */
1730 report("Unknown key, press 'h' for help");
1731 return TRUE;
1732 }
1734 return TRUE;
1735 }
1738 /*
1739 * Pager backend
1740 */
1742 static bool
1743 pager_draw(struct view *view, struct line *line, unsigned int lineno)
1744 {
1745 char *text = line->data;
1746 enum line_type type = line->type;
1747 int textlen = strlen(text);
1748 int attr;
1750 wmove(view->win, lineno, 0);
1752 if (view->offset + lineno == view->lineno) {
1753 if (type == LINE_COMMIT) {
1754 string_copy(view->ref, text + 7);
1755 string_copy(ref_commit, view->ref);
1756 }
1758 type = LINE_CURSOR;
1759 wchgat(view->win, -1, 0, type, NULL);
1760 }
1762 attr = get_line_attr(type);
1763 wattrset(view->win, attr);
1765 if (opt_line_number || opt_tab_size < TABSIZE) {
1766 static char spaces[] = " ";
1767 int col_offset = 0, col = 0;
1769 if (opt_line_number) {
1770 unsigned long real_lineno = view->offset + lineno + 1;
1772 if (real_lineno == 1 ||
1773 (real_lineno % opt_num_interval) == 0) {
1774 wprintw(view->win, "%.*d", view->digits, real_lineno);
1776 } else {
1777 waddnstr(view->win, spaces,
1778 MIN(view->digits, STRING_SIZE(spaces)));
1779 }
1780 waddstr(view->win, ": ");
1781 col_offset = view->digits + 2;
1782 }
1784 while (text && col_offset + col < view->width) {
1785 int cols_max = view->width - col_offset - col;
1786 char *pos = text;
1787 int cols;
1789 if (*text == '\t') {
1790 text++;
1791 assert(sizeof(spaces) > TABSIZE);
1792 pos = spaces;
1793 cols = opt_tab_size - (col % opt_tab_size);
1795 } else {
1796 text = strchr(text, '\t');
1797 cols = line ? text - pos : strlen(pos);
1798 }
1800 waddnstr(view->win, pos, MIN(cols, cols_max));
1801 col += cols;
1802 }
1804 } else {
1805 int col = 0, pos = 0;
1807 for (; pos < textlen && col < view->width; pos++, col++)
1808 if (text[pos] == '\t')
1809 col += TABSIZE - (col % TABSIZE) - 1;
1811 waddnstr(view->win, text, pos);
1812 }
1814 return TRUE;
1815 }
1817 static bool
1818 pager_read(struct view *view, struct line *prev, char *line)
1819 {
1820 /* Compress empty lines in the help view. */
1821 if (view == VIEW(REQ_VIEW_HELP) &&
1822 !*line && prev && !*((char *) prev->data))
1823 return TRUE;
1825 view->line[view->lines].data = strdup(line);
1826 if (!view->line[view->lines].data)
1827 return FALSE;
1829 view->line[view->lines].type = get_line_type(line);
1831 view->lines++;
1832 return TRUE;
1833 }
1835 static bool
1836 pager_enter(struct view *view, struct line *line)
1837 {
1838 int split = 0;
1840 if (line->type == LINE_COMMIT &&
1841 (view == VIEW(REQ_VIEW_LOG) ||
1842 view == VIEW(REQ_VIEW_PAGER))) {
1843 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
1844 split = 1;
1845 }
1847 /* Always scroll the view even if it was split. That way
1848 * you can use Enter to scroll through the log view and
1849 * split open each commit diff. */
1850 scroll_view(view, REQ_SCROLL_LINE_DOWN);
1852 /* FIXME: A minor workaround. Scrolling the view will call report("")
1853 * but if we are scrolling a non-current view this won't properly
1854 * update the view title. */
1855 if (split)
1856 update_view_title(view);
1858 return TRUE;
1859 }
1861 static struct view_ops pager_ops = {
1862 "line",
1863 pager_draw,
1864 pager_read,
1865 pager_enter,
1866 };
1869 /*
1870 * Main view backend
1871 */
1873 struct commit {
1874 char id[41]; /* SHA1 ID. */
1875 char title[75]; /* The first line of the commit message. */
1876 char author[75]; /* The author of the commit. */
1877 struct tm time; /* Date from the author ident. */
1878 struct ref **refs; /* Repository references; tags & branch heads. */
1879 };
1881 static bool
1882 main_draw(struct view *view, struct line *line, unsigned int lineno)
1883 {
1884 char buf[DATE_COLS + 1];
1885 struct commit *commit = line->data;
1886 enum line_type type;
1887 int col = 0;
1888 size_t timelen;
1889 size_t authorlen;
1890 int trimmed = 1;
1892 if (!*commit->author)
1893 return FALSE;
1895 wmove(view->win, lineno, col);
1897 if (view->offset + lineno == view->lineno) {
1898 string_copy(view->ref, commit->id);
1899 string_copy(ref_commit, view->ref);
1900 type = LINE_CURSOR;
1901 wattrset(view->win, get_line_attr(type));
1902 wchgat(view->win, -1, 0, type, NULL);
1904 } else {
1905 type = LINE_MAIN_COMMIT;
1906 wattrset(view->win, get_line_attr(LINE_MAIN_DATE));
1907 }
1909 timelen = strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time);
1910 waddnstr(view->win, buf, timelen);
1911 waddstr(view->win, " ");
1913 col += DATE_COLS;
1914 wmove(view->win, lineno, col);
1915 if (type != LINE_CURSOR)
1916 wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
1918 if (opt_utf8) {
1919 authorlen = utf8_length(commit->author, AUTHOR_COLS - 2, &col, &trimmed);
1920 } else {
1921 authorlen = strlen(commit->author);
1922 if (authorlen > AUTHOR_COLS - 2) {
1923 authorlen = AUTHOR_COLS - 2;
1924 trimmed = 1;
1925 }
1926 }
1928 if (trimmed) {
1929 waddnstr(view->win, commit->author, authorlen);
1930 if (type != LINE_CURSOR)
1931 wattrset(view->win, get_line_attr(LINE_MAIN_DELIM));
1932 waddch(view->win, '~');
1933 } else {
1934 waddstr(view->win, commit->author);
1935 }
1937 col += AUTHOR_COLS;
1938 if (type != LINE_CURSOR)
1939 wattrset(view->win, A_NORMAL);
1941 mvwaddch(view->win, lineno, col, ACS_LTEE);
1942 wmove(view->win, lineno, col + 2);
1943 col += 2;
1945 if (commit->refs) {
1946 size_t i = 0;
1948 do {
1949 if (type == LINE_CURSOR)
1950 ;
1951 else if (commit->refs[i]->tag)
1952 wattrset(view->win, get_line_attr(LINE_MAIN_TAG));
1953 else
1954 wattrset(view->win, get_line_attr(LINE_MAIN_REF));
1955 waddstr(view->win, "[");
1956 waddstr(view->win, commit->refs[i]->name);
1957 waddstr(view->win, "]");
1958 if (type != LINE_CURSOR)
1959 wattrset(view->win, A_NORMAL);
1960 waddstr(view->win, " ");
1961 col += strlen(commit->refs[i]->name) + STRING_SIZE("[] ");
1962 } while (commit->refs[i++]->next);
1963 }
1965 if (type != LINE_CURSOR)
1966 wattrset(view->win, get_line_attr(type));
1968 {
1969 int titlelen = strlen(commit->title);
1971 if (col + titlelen > view->width)
1972 titlelen = view->width - col;
1974 waddnstr(view->win, commit->title, titlelen);
1975 }
1977 return TRUE;
1978 }
1980 /* Reads git log --pretty=raw output and parses it into the commit struct. */
1981 static bool
1982 main_read(struct view *view, struct line *prev, char *line)
1983 {
1984 enum line_type type = get_line_type(line);
1985 struct commit *commit;
1987 switch (type) {
1988 case LINE_COMMIT:
1989 commit = calloc(1, sizeof(struct commit));
1990 if (!commit)
1991 return FALSE;
1993 line += STRING_SIZE("commit ");
1995 view->line[view->lines++].data = commit;
1996 string_copy(commit->id, line);
1997 commit->refs = get_refs(commit->id);
1998 break;
2000 case LINE_AUTHOR:
2001 {
2002 char *ident = line + STRING_SIZE("author ");
2003 char *end = strchr(ident, '<');
2005 if (!prev)
2006 break;
2008 commit = prev->data;
2010 if (end) {
2011 for (; end > ident && isspace(end[-1]); end--) ;
2012 *end = 0;
2013 }
2015 string_copy(commit->author, ident);
2017 /* Parse epoch and timezone */
2018 if (end) {
2019 char *secs = strchr(end + 1, '>');
2020 char *zone;
2021 time_t time;
2023 if (!secs || secs[1] != ' ')
2024 break;
2026 secs += 2;
2027 time = (time_t) atol(secs);
2028 zone = strchr(secs, ' ');
2029 if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
2030 long tz;
2032 zone++;
2033 tz = ('0' - zone[1]) * 60 * 60 * 10;
2034 tz += ('0' - zone[2]) * 60 * 60;
2035 tz += ('0' - zone[3]) * 60;
2036 tz += ('0' - zone[4]) * 60;
2038 if (zone[0] == '-')
2039 tz = -tz;
2041 time -= tz;
2042 }
2043 gmtime_r(&time, &commit->time);
2044 }
2045 break;
2046 }
2047 default:
2048 if (!prev)
2049 break;
2051 commit = prev->data;
2053 /* Fill in the commit title if it has not already been set. */
2054 if (commit->title[0])
2055 break;
2057 /* Require titles to start with a non-space character at the
2058 * offset used by git log. */
2059 /* FIXME: More gracefull handling of titles; append "..." to
2060 * shortened titles, etc. */
2061 if (strncmp(line, " ", 4) ||
2062 isspace(line[4]))
2063 break;
2065 string_copy(commit->title, line + 4);
2066 }
2068 return TRUE;
2069 }
2071 static bool
2072 main_enter(struct view *view, struct line *line)
2073 {
2074 enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
2076 open_view(view, REQ_VIEW_DIFF, flags);
2077 return TRUE;
2078 }
2080 static struct view_ops main_ops = {
2081 "commit",
2082 main_draw,
2083 main_read,
2084 main_enter,
2085 };
2088 /**
2089 * KEYS
2090 * ----
2091 * Below the default key bindings are shown.
2092 **/
2094 struct keymap {
2095 int alias;
2096 int request;
2097 };
2099 static struct keymap keymap[] = {
2100 /**
2101 * View switching
2102 * ~~~~~~~~~~~~~~
2103 * m::
2104 * Switch to main view.
2105 * d::
2106 * Switch to diff view.
2107 * l::
2108 * Switch to log view.
2109 * p::
2110 * Switch to pager view.
2111 * h::
2112 * Show man page.
2113 **/
2114 { 'm', REQ_VIEW_MAIN },
2115 { 'd', REQ_VIEW_DIFF },
2116 { 'l', REQ_VIEW_LOG },
2117 { 'p', REQ_VIEW_PAGER },
2118 { 'h', REQ_VIEW_HELP },
2120 /**
2121 * View manipulation
2122 * ~~~~~~~~~~~~~~~~~
2123 * q::
2124 * Close view, if multiple views are open it will jump back to the
2125 * previous view in the view stack. If it is the last open view it
2126 * will quit. Use 'Q' to quit all views at once.
2127 * Enter::
2128 * This key is "context sensitive" depending on what view you are
2129 * currently in. When in log view on a commit line or in the main
2130 * view, split the view and show the commit diff. In the diff view
2131 * pressing Enter will simply scroll the view one line down.
2132 * Tab::
2133 * Switch to next view.
2134 * Up::
2135 * This key is "context sensitive" and will move the cursor one
2136 * line up. However, uf you opened a diff view from the main view
2137 * (split- or full-screen) it will change the cursor to point to
2138 * the previous commit in the main view and update the diff view
2139 * to display it.
2140 * Down::
2141 * Similar to 'Up' but will move down.
2142 **/
2143 { 'q', REQ_VIEW_CLOSE },
2144 { KEY_TAB, REQ_VIEW_NEXT },
2145 { KEY_RETURN, REQ_ENTER },
2146 { KEY_UP, REQ_PREVIOUS },
2147 { KEY_DOWN, REQ_NEXT },
2149 /**
2150 * Cursor navigation
2151 * ~~~~~~~~~~~~~~~~~
2152 * j::
2153 * Move cursor one line up.
2154 * k::
2155 * Move cursor one line down.
2156 * PgUp::
2157 * b::
2158 * -::
2159 * Move cursor one page up.
2160 * PgDown::
2161 * Space::
2162 * Move cursor one page down.
2163 * Home::
2164 * Jump to first line.
2165 * End::
2166 * Jump to last line.
2167 **/
2168 { 'k', REQ_MOVE_UP },
2169 { 'j', REQ_MOVE_DOWN },
2170 { KEY_HOME, REQ_MOVE_FIRST_LINE },
2171 { KEY_END, REQ_MOVE_LAST_LINE },
2172 { KEY_NPAGE, REQ_MOVE_PAGE_DOWN },
2173 { ' ', REQ_MOVE_PAGE_DOWN },
2174 { KEY_PPAGE, REQ_MOVE_PAGE_UP },
2175 { 'b', REQ_MOVE_PAGE_UP },
2176 { '-', REQ_MOVE_PAGE_UP },
2178 /**
2179 * Scrolling
2180 * ~~~~~~~~~
2181 * Insert::
2182 * Scroll view one line up.
2183 * Delete::
2184 * Scroll view one line down.
2185 * w::
2186 * Scroll view one page up.
2187 * s::
2188 * Scroll view one page down.
2189 **/
2190 { KEY_IC, REQ_SCROLL_LINE_UP },
2191 { KEY_DC, REQ_SCROLL_LINE_DOWN },
2192 { 'w', REQ_SCROLL_PAGE_UP },
2193 { 's', REQ_SCROLL_PAGE_DOWN },
2195 /**
2196 * Misc
2197 * ~~~~
2198 * Q::
2199 * Quit.
2200 * r::
2201 * Redraw screen.
2202 * z::
2203 * Stop all background loading. This can be useful if you use
2204 * tig(1) in a repository with a long history without limiting
2205 * the revision log.
2206 * v::
2207 * Show version.
2208 * n::
2209 * Toggle line numbers on/off.
2210 * ':'::
2211 * Open prompt. This allows you to specify what git command
2212 * to run. Example:
2213 *
2214 * :log -p
2215 **/
2216 { 'Q', REQ_QUIT },
2217 { 'z', REQ_STOP_LOADING },
2218 { 'v', REQ_SHOW_VERSION },
2219 { 'r', REQ_SCREEN_REDRAW },
2220 { 'n', REQ_TOGGLE_LINE_NUMBERS },
2221 { ':', REQ_PROMPT },
2223 /* wgetch() with nodelay() enabled returns ERR when there's no input. */
2224 { ERR, REQ_SCREEN_UPDATE },
2226 /* Use the ncurses SIGWINCH handler. */
2227 { KEY_RESIZE, REQ_SCREEN_RESIZE },
2228 };
2230 static enum request
2231 get_request(int key)
2232 {
2233 int i;
2235 for (i = 0; i < ARRAY_SIZE(keymap); i++)
2236 if (keymap[i].alias == key)
2237 return keymap[i].request;
2239 return (enum request) key;
2240 }
2243 /*
2244 * Unicode / UTF-8 handling
2245 *
2246 * NOTE: Much of the following code for dealing with unicode is derived from
2247 * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
2248 * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
2249 */
2251 /* I've (over)annotated a lot of code snippets because I am not entirely
2252 * confident that the approach taken by this small UTF-8 interface is correct.
2253 * --jonas */
2255 static inline int
2256 unicode_width(unsigned long c)
2257 {
2258 if (c >= 0x1100 &&
2259 (c <= 0x115f /* Hangul Jamo */
2260 || c == 0x2329
2261 || c == 0x232a
2262 || (c >= 0x2e80 && c <= 0xa4cf && c != 0x303f)
2263 /* CJK ... Yi */
2264 || (c >= 0xac00 && c <= 0xd7a3) /* Hangul Syllables */
2265 || (c >= 0xf900 && c <= 0xfaff) /* CJK Compatibility Ideographs */
2266 || (c >= 0xfe30 && c <= 0xfe6f) /* CJK Compatibility Forms */
2267 || (c >= 0xff00 && c <= 0xff60) /* Fullwidth Forms */
2268 || (c >= 0xffe0 && c <= 0xffe6)
2269 || (c >= 0x20000 && c <= 0x2fffd)
2270 || (c >= 0x30000 && c <= 0x3fffd)))
2271 return 2;
2273 return 1;
2274 }
2276 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
2277 * Illegal bytes are set one. */
2278 static const unsigned char utf8_bytes[256] = {
2279 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,
2280 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,
2281 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,
2282 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,
2283 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,
2284 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,
2285 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,
2286 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,
2287 };
2289 /* Decode UTF-8 multi-byte representation into a unicode character. */
2290 static inline unsigned long
2291 utf8_to_unicode(const char *string, size_t length)
2292 {
2293 unsigned long unicode;
2295 switch (length) {
2296 case 1:
2297 unicode = string[0];
2298 break;
2299 case 2:
2300 unicode = (string[0] & 0x1f) << 6;
2301 unicode += (string[1] & 0x3f);
2302 break;
2303 case 3:
2304 unicode = (string[0] & 0x0f) << 12;
2305 unicode += ((string[1] & 0x3f) << 6);
2306 unicode += (string[2] & 0x3f);
2307 break;
2308 case 4:
2309 unicode = (string[0] & 0x0f) << 18;
2310 unicode += ((string[1] & 0x3f) << 12);
2311 unicode += ((string[2] & 0x3f) << 6);
2312 unicode += (string[3] & 0x3f);
2313 break;
2314 case 5:
2315 unicode = (string[0] & 0x0f) << 24;
2316 unicode += ((string[1] & 0x3f) << 18);
2317 unicode += ((string[2] & 0x3f) << 12);
2318 unicode += ((string[3] & 0x3f) << 6);
2319 unicode += (string[4] & 0x3f);
2320 break;
2321 case 6:
2322 unicode = (string[0] & 0x01) << 30;
2323 unicode += ((string[1] & 0x3f) << 24);
2324 unicode += ((string[2] & 0x3f) << 18);
2325 unicode += ((string[3] & 0x3f) << 12);
2326 unicode += ((string[4] & 0x3f) << 6);
2327 unicode += (string[5] & 0x3f);
2328 break;
2329 default:
2330 die("Invalid unicode length");
2331 }
2333 /* Invalid characters could return the special 0xfffd value but NUL
2334 * should be just as good. */
2335 return unicode > 0xffff ? 0 : unicode;
2336 }
2338 /* Calculates how much of string can be shown within the given maximum width
2339 * and sets trimmed parameter to non-zero value if all of string could not be
2340 * shown.
2341 *
2342 * Additionally, adds to coloffset how many many columns to move to align with
2343 * the expected position. Takes into account how multi-byte and double-width
2344 * characters will effect the cursor position.
2345 *
2346 * Returns the number of bytes to output from string to satisfy max_width. */
2347 static size_t
2348 utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed)
2349 {
2350 const char *start = string;
2351 const char *end = strchr(string, '\0');
2352 size_t mbwidth = 0;
2353 size_t width = 0;
2355 *trimmed = 0;
2357 while (string < end) {
2358 int c = *(unsigned char *) string;
2359 unsigned char bytes = utf8_bytes[c];
2360 size_t ucwidth;
2361 unsigned long unicode;
2363 if (string + bytes > end)
2364 break;
2366 /* Change representation to figure out whether
2367 * it is a single- or double-width character. */
2369 unicode = utf8_to_unicode(string, bytes);
2370 /* FIXME: Graceful handling of invalid unicode character. */
2371 if (!unicode)
2372 break;
2374 ucwidth = unicode_width(unicode);
2375 width += ucwidth;
2376 if (width > max_width) {
2377 *trimmed = 1;
2378 break;
2379 }
2381 /* The column offset collects the differences between the
2382 * number of bytes encoding a character and the number of
2383 * columns will be used for rendering said character.
2384 *
2385 * So if some character A is encoded in 2 bytes, but will be
2386 * represented on the screen using only 1 byte this will and up
2387 * adding 1 to the multi-byte column offset.
2388 *
2389 * Assumes that no double-width character can be encoding in
2390 * less than two bytes. */
2391 if (bytes > ucwidth)
2392 mbwidth += bytes - ucwidth;
2394 string += bytes;
2395 }
2397 *coloffset += mbwidth;
2399 return string - start;
2400 }
2403 /*
2404 * Status management
2405 */
2407 /* Whether or not the curses interface has been initialized. */
2408 static bool cursed = FALSE;
2410 /* The status window is used for polling keystrokes. */
2411 static WINDOW *status_win;
2413 /* Update status and title window. */
2414 static void
2415 report(const char *msg, ...)
2416 {
2417 static bool empty = TRUE;
2418 struct view *view = display[current_view];
2420 if (!empty || *msg) {
2421 va_list args;
2423 va_start(args, msg);
2425 werase(status_win);
2426 wmove(status_win, 0, 0);
2427 if (*msg) {
2428 vwprintw(status_win, msg, args);
2429 empty = FALSE;
2430 } else {
2431 empty = TRUE;
2432 }
2433 wrefresh(status_win);
2435 va_end(args);
2436 }
2438 update_view_title(view);
2439 update_display_cursor();
2440 }
2442 /* Controls when nodelay should be in effect when polling user input. */
2443 static void
2444 set_nonblocking_input(bool loading)
2445 {
2446 static unsigned int loading_views;
2448 if ((loading == FALSE && loading_views-- == 1) ||
2449 (loading == TRUE && loading_views++ == 0))
2450 nodelay(status_win, loading);
2451 }
2453 static void
2454 init_display(void)
2455 {
2456 int x, y;
2458 /* Initialize the curses library */
2459 if (isatty(STDIN_FILENO)) {
2460 cursed = !!initscr();
2461 } else {
2462 /* Leave stdin and stdout alone when acting as a pager. */
2463 FILE *io = fopen("/dev/tty", "r+");
2465 cursed = !!newterm(NULL, io, io);
2466 }
2468 if (!cursed)
2469 die("Failed to initialize curses");
2471 nonl(); /* Tell curses not to do NL->CR/NL on output */
2472 cbreak(); /* Take input chars one at a time, no wait for \n */
2473 noecho(); /* Don't echo input */
2474 leaveok(stdscr, TRUE);
2476 if (has_colors())
2477 init_colors();
2479 getmaxyx(stdscr, y, x);
2480 status_win = newwin(1, 0, y - 1, 0);
2481 if (!status_win)
2482 die("Failed to create status window");
2484 /* Enable keyboard mapping */
2485 keypad(status_win, TRUE);
2486 wbkgdset(status_win, get_line_attr(LINE_STATUS));
2487 }
2490 /*
2491 * Repository references
2492 */
2494 static struct ref *refs;
2495 static size_t refs_size;
2497 /* Id <-> ref store */
2498 static struct ref ***id_refs;
2499 static size_t id_refs_size;
2501 static struct ref **
2502 get_refs(char *id)
2503 {
2504 struct ref ***tmp_id_refs;
2505 struct ref **ref_list = NULL;
2506 size_t ref_list_size = 0;
2507 size_t i;
2509 for (i = 0; i < id_refs_size; i++)
2510 if (!strcmp(id, id_refs[i][0]->id))
2511 return id_refs[i];
2513 tmp_id_refs = realloc(id_refs, (id_refs_size + 1) * sizeof(*id_refs));
2514 if (!tmp_id_refs)
2515 return NULL;
2517 id_refs = tmp_id_refs;
2519 for (i = 0; i < refs_size; i++) {
2520 struct ref **tmp;
2522 if (strcmp(id, refs[i].id))
2523 continue;
2525 tmp = realloc(ref_list, (ref_list_size + 1) * sizeof(*ref_list));
2526 if (!tmp) {
2527 if (ref_list)
2528 free(ref_list);
2529 return NULL;
2530 }
2532 ref_list = tmp;
2533 if (ref_list_size > 0)
2534 ref_list[ref_list_size - 1]->next = 1;
2535 ref_list[ref_list_size] = &refs[i];
2537 /* XXX: The properties of the commit chains ensures that we can
2538 * safely modify the shared ref. The repo references will
2539 * always be similar for the same id. */
2540 ref_list[ref_list_size]->next = 0;
2541 ref_list_size++;
2542 }
2544 if (ref_list)
2545 id_refs[id_refs_size++] = ref_list;
2547 return ref_list;
2548 }
2550 static int
2551 read_ref(char *id, int idlen, char *name, int namelen)
2552 {
2553 struct ref *ref;
2554 bool tag = FALSE;
2555 bool tag_commit = FALSE;
2557 /* Commits referenced by tags has "^{}" appended. */
2558 if (name[namelen - 1] == '}') {
2559 while (namelen > 0 && name[namelen] != '^')
2560 namelen--;
2561 if (namelen > 0)
2562 tag_commit = TRUE;
2563 name[namelen] = 0;
2564 }
2566 if (!strncmp(name, "refs/tags/", STRING_SIZE("refs/tags/"))) {
2567 if (!tag_commit)
2568 return OK;
2569 name += STRING_SIZE("refs/tags/");
2570 tag = TRUE;
2572 } else if (!strncmp(name, "refs/heads/", STRING_SIZE("refs/heads/"))) {
2573 name += STRING_SIZE("refs/heads/");
2575 } else if (!strcmp(name, "HEAD")) {
2576 return OK;
2577 }
2579 refs = realloc(refs, sizeof(*refs) * (refs_size + 1));
2580 if (!refs)
2581 return ERR;
2583 ref = &refs[refs_size++];
2584 ref->name = strdup(name);
2585 if (!ref->name)
2586 return ERR;
2588 ref->tag = tag;
2589 string_copy(ref->id, id);
2591 return OK;
2592 }
2594 static int
2595 load_refs(void)
2596 {
2597 const char *cmd_env = getenv("TIG_LS_REMOTE");
2598 const char *cmd = cmd_env && *cmd_env ? cmd_env : TIG_LS_REMOTE;
2600 return read_properties(popen(cmd, "r"), "\t", read_ref);
2601 }
2603 static int
2604 read_repo_config_option(char *name, int namelen, char *value, int valuelen)
2605 {
2606 if (!strcmp(name, "i18n.commitencoding")) {
2607 string_copy(opt_encoding, value);
2608 }
2610 return OK;
2611 }
2613 static int
2614 load_repo_config(void)
2615 {
2616 return read_properties(popen("git repo-config --list", "r"),
2617 "=", read_repo_config_option);
2618 }
2620 static int
2621 read_properties(FILE *pipe, const char *separators,
2622 int (*read_property)(char *, int, char *, int))
2623 {
2624 char buffer[BUFSIZ];
2625 char *name;
2626 int state = OK;
2628 if (!pipe)
2629 return ERR;
2631 while (state == OK && (name = fgets(buffer, sizeof(buffer), pipe))) {
2632 char *value;
2633 size_t namelen;
2634 size_t valuelen;
2636 name = chomp_string(name);
2637 namelen = strcspn(name, separators);
2639 if (name[namelen]) {
2640 name[namelen] = 0;
2641 value = chomp_string(name + namelen + 1);
2642 valuelen = strlen(value);
2644 } else {
2645 value = "";
2646 valuelen = 0;
2647 }
2649 state = read_property(name, namelen, value, valuelen);
2650 }
2652 if (state != ERR && ferror(pipe))
2653 state = ERR;
2655 pclose(pipe);
2657 return state;
2658 }
2661 /*
2662 * Main
2663 */
2665 #if __GNUC__ >= 3
2666 #define __NORETURN __attribute__((__noreturn__))
2667 #else
2668 #define __NORETURN
2669 #endif
2671 static void __NORETURN
2672 quit(int sig)
2673 {
2674 /* XXX: Restore tty modes and let the OS cleanup the rest! */
2675 if (cursed)
2676 endwin();
2677 exit(0);
2678 }
2680 static void __NORETURN
2681 die(const char *err, ...)
2682 {
2683 va_list args;
2685 endwin();
2687 va_start(args, err);
2688 fputs("tig: ", stderr);
2689 vfprintf(stderr, err, args);
2690 fputs("\n", stderr);
2691 va_end(args);
2693 exit(1);
2694 }
2696 int
2697 main(int argc, char *argv[])
2698 {
2699 struct view *view;
2700 enum request request;
2701 size_t i;
2703 signal(SIGINT, quit);
2705 if (load_options() == ERR)
2706 die("Failed to load user config.");
2708 /* Load the repo config file so options can be overwritten from
2709 * the command line. */
2710 if (load_repo_config() == ERR)
2711 die("Failed to load repo config.");
2713 if (!parse_options(argc, argv))
2714 return 0;
2716 if (load_refs() == ERR)
2717 die("Failed to load refs.");
2719 /* Require a git repository unless when running in pager mode. */
2720 if (refs_size == 0 && opt_request != REQ_VIEW_PAGER)
2721 die("Not a git repository");
2723 for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
2724 view->cmd_env = getenv(view->cmd_env);
2726 request = opt_request;
2728 init_display();
2730 while (view_driver(display[current_view], request)) {
2731 int key;
2732 int i;
2734 foreach_view (view, i)
2735 update_view(view);
2737 /* Refresh, accept single keystroke of input */
2738 key = wgetch(status_win);
2739 request = get_request(key);
2741 /* Some low-level request handling. This keeps access to
2742 * status_win restricted. */
2743 switch (request) {
2744 case REQ_PROMPT:
2745 report(":");
2746 /* Temporarily switch to line-oriented and echoed
2747 * input. */
2748 nocbreak();
2749 echo();
2751 if (wgetnstr(status_win, opt_cmd + 4, sizeof(opt_cmd) - 4) == OK) {
2752 memcpy(opt_cmd, "git ", 4);
2753 opt_request = REQ_VIEW_PAGER;
2754 } else {
2755 report("Prompt interrupted by loading view, "
2756 "press 'z' to stop loading views");
2757 request = REQ_SCREEN_UPDATE;
2758 }
2760 noecho();
2761 cbreak();
2762 break;
2764 case REQ_SCREEN_RESIZE:
2765 {
2766 int height, width;
2768 getmaxyx(stdscr, height, width);
2770 /* Resize the status view and let the view driver take
2771 * care of resizing the displayed views. */
2772 wresize(status_win, 1, width);
2773 mvwin(status_win, height - 1, 0);
2774 wrefresh(status_win);
2775 break;
2776 }
2777 default:
2778 break;
2779 }
2780 }
2782 quit(0);
2784 return 0;
2785 }
2787 /**
2788 * [[refspec]]
2789 * Revision specification
2790 * ----------------------
2791 * This section describes various ways to specify what revisions to display
2792 * or otherwise limit the view to. tig(1) does not itself parse the described
2793 * revision options so refer to the relevant git man pages for futher
2794 * information. Relevant man pages besides git-log(1) are git-diff(1) and
2795 * git-rev-list(1).
2796 *
2797 * You can tune the interaction with git by making use of the options
2798 * explained in this section. For example, by configuring the environment
2799 * variables described in the <<history-commands, "History commands">>
2800 * section.
2801 *
2802 * Limit by path name
2803 * ~~~~~~~~~~~~~~~~~~
2804 * If you are interested only in those revisions that made changes to a
2805 * specific file (or even several files) list the files like this:
2806 *
2807 * $ tig log Makefile README
2808 *
2809 * To avoid ambiguity with repository references such as tag name, be sure
2810 * to separate file names from other git options using "\--". So if you
2811 * have a file named 'master' it will clash with the reference named
2812 * 'master', and thus you will have to use:
2813 *
2814 * $ tig log -- master
2815 *
2816 * NOTE: For the main view, avoiding ambiguity will in some cases require
2817 * you to specify two "\--" options. The first will make tig(1) stop
2818 * option processing and the latter will be passed to git log.
2819 *
2820 * Limit by date or number
2821 * ~~~~~~~~~~~~~~~~~~~~~~~
2822 * To speed up interaction with git, you can limit the amount of commits
2823 * to show both for the log and main view. Either limit by date using
2824 * e.g. `--since=1.month` or limit by the number of commits using `-n400`.
2825 *
2826 * If you are only interested in changed that happened between two dates
2827 * you can use:
2828 *
2829 * $ tig -- --after="May 5th" --before="2006-05-16 15:44"
2830 *
2831 * NOTE: If you want to avoid having to quote dates containing spaces you
2832 * can use "." instead, e.g. `--after=May.5th`.
2833 *
2834 * Limiting by commit ranges
2835 * ~~~~~~~~~~~~~~~~~~~~~~~~~
2836 * Alternatively, commits can be limited to a specific range, such as
2837 * "all commits between 'tag-1.0' and 'tag-2.0'". For example:
2838 *
2839 * $ tig log tag-1.0..tag-2.0
2840 *
2841 * This way of commit limiting makes it trivial to only browse the commits
2842 * which haven't been pushed to a remote branch. Assuming 'origin' is your
2843 * upstream remote branch, using:
2844 *
2845 * $ tig log origin..HEAD
2846 *
2847 * will list what will be pushed to the remote branch. Optionally, the ending
2848 * 'HEAD' can be left out since it is implied.
2849 *
2850 * Limiting by reachability
2851 * ~~~~~~~~~~~~~~~~~~~~~~~~
2852 * Git interprets the range specifier "tag-1.0..tag-2.0" as
2853 * "all commits reachable from 'tag-2.0' but not from 'tag-1.0'".
2854 * Where reachability refers to what commits are ancestors (or part of the
2855 * history) of the branch or tagged revision in question.
2856 *
2857 * If you prefer to specify which commit to preview in this way use the
2858 * following:
2859 *
2860 * $ tig log tag-2.0 ^tag-1.0
2861 *
2862 * You can think of '^' as a negation operator. Using this alternate syntax,
2863 * it is possible to further prune commits by specifying multiple branch
2864 * cut offs.
2865 *
2866 * Combining revisions specification
2867 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2868 * Revisions options can to some degree be combined, which makes it possible
2869 * to say "show at most 20 commits from within the last month that changed
2870 * files under the Documentation/ directory."
2871 *
2872 * $ tig -- --since=1.month -n20 -- Documentation/
2873 *
2874 * Examining all repository references
2875 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2876 * In some cases, it can be useful to query changes across all references
2877 * in a repository. An example is to ask "did any line of development in
2878 * this repository change a particular file within the last week". This
2879 * can be accomplished using:
2880 *
2881 * $ tig -- --all --since=1.week -- Makefile
2882 *
2883 * BUGS
2884 * ----
2885 * Known bugs and problems:
2886 *
2887 * - In it's current state tig is pretty much UTF-8 only.
2888 *
2889 * - If the screen width is very small the main view can draw
2890 * outside the current view causing bad wrapping. Same goes
2891 * for title and status windows.
2892 *
2893 * - The cursor can wrap-around on the last line and cause the
2894 * window to scroll.
2895 *
2896 * - The prompt doesn't work while loading.
2897 *
2898 * TODO
2899 * ----
2900 * Features that should be explored.
2901 *
2902 * - Searching.
2903 *
2904 * - Locale support.
2905 *
2906 * - Make '?' show a one page keybinding cheat sheet.
2907 *
2908 * COPYRIGHT
2909 * ---------
2910 * Copyright (c) 2006 Jonas Fonseca <fonseca@diku.dk>
2911 *
2912 * This program is free software; you can redistribute it and/or modify
2913 * it under the terms of the GNU General Public License as published by
2914 * the Free Software Foundation; either version 2 of the License, or
2915 * (at your option) any later version.
2916 *
2917 * SEE ALSO
2918 * --------
2919 * - link:http://www.kernel.org/pub/software/scm/git/docs/[git(7)],
2920 * - link:http://www.kernel.org/pub/software/scm/cogito/docs/[cogito(7)]
2921 *
2922 * Other git repository browsers:
2923 *
2924 * - gitk(1)
2925 * - qgit(1)
2926 * - gitview(1)
2927 **/