1 /* Copyright (c) 2006-2008 Jonas Fonseca <fonseca@diku.dk>
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.
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.
19 #define TIG_VERSION "unknown-version"
34 #include <sys/types.h>
45 /* ncurses(3): Must be defined to have extended wide-character functions. */
46 #define _XOPEN_SOURCE_EXTENDED
51 #define __NORETURN __attribute__((__noreturn__))
56 static void __NORETURN die(const char *err, ...);
57 static void warn(const char *msg, ...);
58 static void report(const char *msg, ...);
59 static int read_properties(FILE *pipe, const char *separators, int (*read)(char *, size_t, char *, size_t));
60 static void set_nonblocking_input(bool loading);
61 static size_t utf8_length(const char *string, size_t max_width, int *trimmed, bool reserve);
63 #define ABS(x) ((x) >= 0 ? (x) : -(x))
64 #define MIN(x, y) ((x) < (y) ? (x) : (y))
66 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
67 #define STRING_SIZE(x) (sizeof(x) - 1)
69 #define SIZEOF_STR 1024 /* Default string size. */
70 #define SIZEOF_REF 256 /* Size of symbolic or SHA1 ID. */
71 #define SIZEOF_REV 41 /* Holds a SHA-1 and an ending NUL */
75 #define REVGRAPH_INIT 'I'
76 #define REVGRAPH_MERGE 'M'
77 #define REVGRAPH_BRANCH '+'
78 #define REVGRAPH_COMMIT '*'
79 #define REVGRAPH_BOUND '^'
80 #define REVGRAPH_LINE '|'
82 #define SIZEOF_REVGRAPH 19 /* Size of revision ancestry graphics. */
84 /* This color name can be used to refer to the default term colors. */
85 #define COLOR_DEFAULT (-1)
87 #define ICONV_NONE ((iconv_t) -1)
89 #define ICONV_CONST /* nothing */
92 /* The format and size of the date column in the main view. */
93 #define DATE_FORMAT "%Y-%m-%d %H:%M"
94 #define DATE_COLS STRING_SIZE("2006-04-29 14:21 ")
96 #define AUTHOR_COLS 20
99 /* The default interval between line numbers. */
100 #define NUMBER_INTERVAL 5
104 #define SCALE_SPLIT_VIEW(height) ((height) * 2 / 3)
106 #define NULL_ID "0000000000000000000000000000000000000000"
109 #define GIT_CONFIG "git config"
112 #define TIG_LS_REMOTE \
113 "git ls-remote $(git rev-parse --git-dir) 2>/dev/null"
115 #define TIG_DIFF_CMD \
116 "git show --pretty=fuller --no-color --root --patch-with-stat --find-copies-harder -C %s 2>/dev/null"
118 #define TIG_LOG_CMD \
119 "git log --no-color --cc --stat -n100 %s 2>/dev/null"
121 #define TIG_MAIN_CMD \
122 "git log --no-color --topo-order --parents --boundary --pretty=raw %s 2>/dev/null"
124 #define TIG_TREE_CMD \
127 #define TIG_BLOB_CMD \
128 "git cat-file blob %s"
130 /* XXX: Needs to be defined to the empty string. */
131 #define TIG_HELP_CMD ""
132 #define TIG_PAGER_CMD ""
133 #define TIG_STATUS_CMD ""
134 #define TIG_STAGE_CMD ""
135 #define TIG_BLAME_CMD ""
137 /* Some ascii-shorthands fitted into the ncurses namespace. */
139 #define KEY_RETURN '\r'
144 char *name; /* Ref name; tag or head names are shortened. */
145 char id[SIZEOF_REV]; /* Commit SHA1 ID */
146 unsigned int head:1; /* Is it the current HEAD? */
147 unsigned int tag:1; /* Is it a tag? */
148 unsigned int ltag:1; /* If so, is the tag local? */
149 unsigned int remote:1; /* Is it a remote ref? */
150 unsigned int tracked:1; /* Is it the remote for the current HEAD? */
151 unsigned int next:1; /* For ref lists: are there more refs? */
154 static struct ref **get_refs(char *id);
163 set_from_int_map(struct int_map *map, size_t map_size,
164 int *value, const char *name, int namelen)
169 for (i = 0; i < map_size; i++)
170 if (namelen == map[i].namelen &&
171 !strncasecmp(name, map[i].name, namelen)) {
172 *value = map[i].value;
185 string_ncopy_do(char *dst, size_t dstlen, const char *src, size_t srclen)
187 if (srclen > dstlen - 1)
190 strncpy(dst, src, srclen);
194 /* Shorthands for safely copying into a fixed buffer. */
196 #define string_copy(dst, src) \
197 string_ncopy_do(dst, sizeof(dst), src, sizeof(src))
199 #define string_ncopy(dst, src, srclen) \
200 string_ncopy_do(dst, sizeof(dst), src, srclen)
202 #define string_copy_rev(dst, src) \
203 string_ncopy_do(dst, SIZEOF_REV, src, SIZEOF_REV - 1)
205 #define string_add(dst, from, src) \
206 string_ncopy_do(dst + (from), sizeof(dst) - (from), src, sizeof(src))
209 chomp_string(char *name)
213 while (isspace(*name))
216 namelen = strlen(name) - 1;
217 while (namelen > 0 && isspace(name[namelen]))
224 string_nformat(char *buf, size_t bufsize, size_t *bufpos, const char *fmt, ...)
227 size_t pos = bufpos ? *bufpos : 0;
230 pos += vsnprintf(buf + pos, bufsize - pos, fmt, args);
236 return pos >= bufsize ? FALSE : TRUE;
239 #define string_format(buf, fmt, args...) \
240 string_nformat(buf, sizeof(buf), NULL, fmt, args)
242 #define string_format_from(buf, from, fmt, args...) \
243 string_nformat(buf, sizeof(buf), from, fmt, args)
246 string_enum_compare(const char *str1, const char *str2, int len)
250 #define string_enum_sep(x) ((x) == '-' || (x) == '_' || (x) == '.')
252 /* Diff-Header == DIFF_HEADER */
253 for (i = 0; i < len; i++) {
254 if (toupper(str1[i]) == toupper(str2[i]))
257 if (string_enum_sep(str1[i]) &&
258 string_enum_sep(str2[i]))
261 return str1[i] - str2[i];
269 * NOTE: The following is a slightly modified copy of the git project's shell
270 * quoting routines found in the quote.c file.
272 * Help to copy the thing properly quoted for the shell safety. any single
273 * quote is replaced with '\'', any exclamation point is replaced with '\!',
274 * and the whole thing is enclosed in a
277 * original sq_quote result
278 * name ==> name ==> 'name'
279 * a b ==> a b ==> 'a b'
280 * a'b ==> a'\''b ==> 'a'\''b'
281 * a!b ==> a'\!'b ==> 'a'\!'b'
285 sq_quote(char buf[SIZEOF_STR], size_t bufsize, const char *src)
289 #define BUFPUT(x) do { if (bufsize < SIZEOF_STR) buf[bufsize++] = (x); } while (0)
292 while ((c = *src++)) {
293 if (c == '\'' || c == '!') {
304 if (bufsize < SIZEOF_STR)
316 /* XXX: Keep the view request first and in sync with views[]. */ \
317 REQ_GROUP("View switching") \
318 REQ_(VIEW_MAIN, "Show main view"), \
319 REQ_(VIEW_DIFF, "Show diff view"), \
320 REQ_(VIEW_LOG, "Show log view"), \
321 REQ_(VIEW_TREE, "Show tree view"), \
322 REQ_(VIEW_BLOB, "Show blob view"), \
323 REQ_(VIEW_BLAME, "Show blame view"), \
324 REQ_(VIEW_HELP, "Show help page"), \
325 REQ_(VIEW_PAGER, "Show pager view"), \
326 REQ_(VIEW_STATUS, "Show status view"), \
327 REQ_(VIEW_STAGE, "Show stage view"), \
329 REQ_GROUP("View manipulation") \
330 REQ_(ENTER, "Enter current line and scroll"), \
331 REQ_(NEXT, "Move to next"), \
332 REQ_(PREVIOUS, "Move to previous"), \
333 REQ_(VIEW_NEXT, "Move focus to next view"), \
334 REQ_(REFRESH, "Reload and refresh"), \
335 REQ_(VIEW_CLOSE, "Close the current view"), \
336 REQ_(QUIT, "Close all views and quit"), \
338 REQ_GROUP("Cursor navigation") \
339 REQ_(MOVE_UP, "Move cursor one line up"), \
340 REQ_(MOVE_DOWN, "Move cursor one line down"), \
341 REQ_(MOVE_PAGE_DOWN, "Move cursor one page down"), \
342 REQ_(MOVE_PAGE_UP, "Move cursor one page up"), \
343 REQ_(MOVE_FIRST_LINE, "Move cursor to first line"), \
344 REQ_(MOVE_LAST_LINE, "Move cursor to last line"), \
346 REQ_GROUP("Scrolling") \
347 REQ_(SCROLL_LINE_UP, "Scroll one line up"), \
348 REQ_(SCROLL_LINE_DOWN, "Scroll one line down"), \
349 REQ_(SCROLL_PAGE_UP, "Scroll one page up"), \
350 REQ_(SCROLL_PAGE_DOWN, "Scroll one page down"), \
352 REQ_GROUP("Searching") \
353 REQ_(SEARCH, "Search the view"), \
354 REQ_(SEARCH_BACK, "Search backwards in the view"), \
355 REQ_(FIND_NEXT, "Find next search match"), \
356 REQ_(FIND_PREV, "Find previous search match"), \
359 REQ_(PROMPT, "Bring up the prompt"), \
360 REQ_(SCREEN_REDRAW, "Redraw the screen"), \
361 REQ_(SCREEN_RESIZE, "Resize the screen"), \
362 REQ_(SHOW_VERSION, "Show version information"), \
363 REQ_(STOP_LOADING, "Stop all loading views"), \
364 REQ_(TOGGLE_LINENO, "Toggle line numbers"), \
365 REQ_(TOGGLE_DATE, "Toggle date display"), \
366 REQ_(TOGGLE_AUTHOR, "Toggle author display"), \
367 REQ_(TOGGLE_REV_GRAPH, "Toggle revision graph visualization"), \
368 REQ_(TOGGLE_REFS, "Toggle reference display (tags/branches)"), \
369 REQ_(STATUS_UPDATE, "Update file status"), \
370 REQ_(STATUS_MERGE, "Merge file using external tool"), \
371 REQ_(TREE_PARENT, "Switch to parent directory in tree view"), \
372 REQ_(EDIT, "Open in editor"), \
373 REQ_(NONE, "Do nothing")
376 /* User action requests. */
378 #define REQ_GROUP(help)
379 #define REQ_(req, help) REQ_##req
381 /* Offset all requests to avoid conflicts with ncurses getch values. */
382 REQ_OFFSET = KEY_MAX + 1,
389 struct request_info {
390 enum request request;
396 static struct request_info req_info[] = {
397 #define REQ_GROUP(help) { 0, NULL, 0, (help) },
398 #define REQ_(req, help) { REQ_##req, (#req), STRING_SIZE(#req), (help) }
405 get_request(const char *name)
407 int namelen = strlen(name);
410 for (i = 0; i < ARRAY_SIZE(req_info); i++)
411 if (req_info[i].namelen == namelen &&
412 !string_enum_compare(req_info[i].name, name, namelen))
413 return req_info[i].request;
423 static const char usage[] =
424 "tig " TIG_VERSION " (" __DATE__ ")\n"
426 "Usage: tig [options] [revs] [--] [paths]\n"
427 " or: tig show [options] [revs] [--] [paths]\n"
428 " or: tig blame [rev] path\n"
430 " or: tig < [git command output]\n"
433 " -v, --version Show version and exit\n"
434 " -h, --help Show help message and exit";
436 /* Option and state variables. */
437 static bool opt_date = TRUE;
438 static bool opt_author = TRUE;
439 static bool opt_line_number = FALSE;
440 static bool opt_rev_graph = FALSE;
441 static bool opt_show_refs = TRUE;
442 static int opt_num_interval = NUMBER_INTERVAL;
443 static int opt_tab_size = TABSIZE;
444 static enum request opt_request = REQ_VIEW_MAIN;
445 static char opt_cmd[SIZEOF_STR] = "";
446 static char opt_path[SIZEOF_STR] = "";
447 static char opt_file[SIZEOF_STR] = "";
448 static char opt_ref[SIZEOF_REF] = "";
449 static char opt_head[SIZEOF_REF] = "";
450 static char opt_remote[SIZEOF_REF] = "";
451 static bool opt_no_head = TRUE;
452 static FILE *opt_pipe = NULL;
453 static char opt_encoding[20] = "UTF-8";
454 static bool opt_utf8 = TRUE;
455 static char opt_codeset[20] = "UTF-8";
456 static iconv_t opt_iconv = ICONV_NONE;
457 static char opt_search[SIZEOF_STR] = "";
458 static char opt_cdup[SIZEOF_STR] = "";
459 static char opt_git_dir[SIZEOF_STR] = "";
460 static signed char opt_is_inside_work_tree = -1; /* set to TRUE or FALSE */
461 static char opt_editor[SIZEOF_STR] = "";
464 parse_options(int argc, char *argv[])
468 bool seen_dashdash = FALSE;
471 if (!isatty(STDIN_FILENO)) {
472 opt_request = REQ_VIEW_PAGER;
480 subcommand = argv[1];
481 if (!strcmp(subcommand, "status") || !strcmp(subcommand, "-S")) {
482 opt_request = REQ_VIEW_STATUS;
483 if (!strcmp(subcommand, "-S"))
484 warn("`-S' has been deprecated; use `tig status' instead");
486 warn("ignoring arguments after `%s'", subcommand);
489 } else if (!strcmp(subcommand, "blame")) {
490 opt_request = REQ_VIEW_BLAME;
491 if (argc <= 2 || argc > 4)
492 die("invalid number of options to blame\n\n%s", usage);
496 string_ncopy(opt_ref, argv[i], strlen(argv[i]));
500 string_ncopy(opt_file, argv[i], strlen(argv[i]));
503 } else if (!strcmp(subcommand, "show")) {
504 opt_request = REQ_VIEW_DIFF;
506 } else if (!strcmp(subcommand, "log") || !strcmp(subcommand, "diff")) {
507 opt_request = subcommand[0] == 'l'
508 ? REQ_VIEW_LOG : REQ_VIEW_DIFF;
509 warn("`tig %s' has been deprecated", subcommand);
516 /* XXX: This is vulnerable to the user overriding
517 * options required for the main view parser. */
518 string_copy(opt_cmd, "git log --no-color --pretty=raw --boundary --parents");
520 string_format(opt_cmd, "git %s", subcommand);
522 buf_size = strlen(opt_cmd);
524 for (i = 1 + !!subcommand; i < argc; i++) {
527 if (seen_dashdash || !strcmp(opt, "--")) {
528 seen_dashdash = TRUE;
530 } else if (!strcmp(opt, "-v") || !strcmp(opt, "--version")) {
531 printf("tig version %s\n", TIG_VERSION);
534 } else if (!strcmp(opt, "-h") || !strcmp(opt, "--help")) {
535 printf("%s\n", usage);
539 opt_cmd[buf_size++] = ' ';
540 buf_size = sq_quote(opt_cmd, buf_size, opt);
541 if (buf_size >= sizeof(opt_cmd))
542 die("command too long");
545 opt_cmd[buf_size] = 0;
552 * Line-oriented content detection.
556 LINE(DIFF_HEADER, "diff --git ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
557 LINE(DIFF_CHUNK, "@@", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
558 LINE(DIFF_ADD, "+", COLOR_GREEN, COLOR_DEFAULT, 0), \
559 LINE(DIFF_DEL, "-", COLOR_RED, COLOR_DEFAULT, 0), \
560 LINE(DIFF_INDEX, "index ", COLOR_BLUE, COLOR_DEFAULT, 0), \
561 LINE(DIFF_OLDMODE, "old file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
562 LINE(DIFF_NEWMODE, "new file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
563 LINE(DIFF_COPY_FROM, "copy from", COLOR_YELLOW, COLOR_DEFAULT, 0), \
564 LINE(DIFF_COPY_TO, "copy to", COLOR_YELLOW, COLOR_DEFAULT, 0), \
565 LINE(DIFF_RENAME_FROM, "rename from", COLOR_YELLOW, COLOR_DEFAULT, 0), \
566 LINE(DIFF_RENAME_TO, "rename to", COLOR_YELLOW, COLOR_DEFAULT, 0), \
567 LINE(DIFF_SIMILARITY, "similarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
568 LINE(DIFF_DISSIMILARITY,"dissimilarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
569 LINE(DIFF_TREE, "diff-tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
570 LINE(PP_AUTHOR, "Author: ", COLOR_CYAN, COLOR_DEFAULT, 0), \
571 LINE(PP_COMMIT, "Commit: ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
572 LINE(PP_MERGE, "Merge: ", COLOR_BLUE, COLOR_DEFAULT, 0), \
573 LINE(PP_DATE, "Date: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
574 LINE(PP_ADATE, "AuthorDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
575 LINE(PP_CDATE, "CommitDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
576 LINE(PP_REFS, "Refs: ", COLOR_RED, COLOR_DEFAULT, 0), \
577 LINE(COMMIT, "commit ", COLOR_GREEN, COLOR_DEFAULT, 0), \
578 LINE(PARENT, "parent ", COLOR_BLUE, COLOR_DEFAULT, 0), \
579 LINE(TREE, "tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
580 LINE(AUTHOR, "author ", COLOR_CYAN, COLOR_DEFAULT, 0), \
581 LINE(COMMITTER, "committer ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
582 LINE(SIGNOFF, " Signed-off-by", COLOR_YELLOW, COLOR_DEFAULT, 0), \
583 LINE(ACKED, " Acked-by", COLOR_YELLOW, COLOR_DEFAULT, 0), \
584 LINE(DEFAULT, "", COLOR_DEFAULT, COLOR_DEFAULT, A_NORMAL), \
585 LINE(CURSOR, "", COLOR_WHITE, COLOR_GREEN, A_BOLD), \
586 LINE(STATUS, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
587 LINE(DELIMITER, "", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
588 LINE(TITLE_BLUR, "", COLOR_WHITE, COLOR_BLUE, 0), \
589 LINE(TITLE_FOCUS, "", COLOR_WHITE, COLOR_BLUE, A_BOLD), \
590 LINE(MAIN_DATE, "", COLOR_BLUE, COLOR_DEFAULT, 0), \
591 LINE(MAIN_AUTHOR, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
592 LINE(MAIN_COMMIT, "", COLOR_DEFAULT, COLOR_DEFAULT, 0), \
593 LINE(MAIN_TAG, "", COLOR_MAGENTA, COLOR_DEFAULT, A_BOLD), \
594 LINE(MAIN_LOCAL_TAG,"", COLOR_MAGENTA, COLOR_DEFAULT, A_BOLD), \
595 LINE(MAIN_REMOTE, "", COLOR_YELLOW, COLOR_DEFAULT, 0), \
596 LINE(MAIN_TRACKED, "", COLOR_YELLOW, COLOR_DEFAULT, A_BOLD), \
597 LINE(MAIN_REF, "", COLOR_CYAN, COLOR_DEFAULT, A_BOLD), \
598 LINE(MAIN_HEAD, "", COLOR_RED, COLOR_DEFAULT, A_BOLD), \
599 LINE(MAIN_REVGRAPH,"", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
600 LINE(TREE_DIR, "", COLOR_DEFAULT, COLOR_DEFAULT, A_NORMAL), \
601 LINE(TREE_FILE, "", COLOR_DEFAULT, COLOR_DEFAULT, A_NORMAL), \
602 LINE(STAT_HEAD, "", COLOR_YELLOW, COLOR_DEFAULT, 0), \
603 LINE(STAT_SECTION, "", COLOR_CYAN, COLOR_DEFAULT, 0), \
604 LINE(STAT_NONE, "", COLOR_DEFAULT, COLOR_DEFAULT, 0), \
605 LINE(STAT_STAGED, "", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
606 LINE(STAT_UNSTAGED,"", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
607 LINE(STAT_UNTRACKED,"", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
608 LINE(BLAME_DATE, "", COLOR_BLUE, COLOR_DEFAULT, 0), \
609 LINE(BLAME_AUTHOR, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
610 LINE(BLAME_COMMIT, "", COLOR_DEFAULT, COLOR_DEFAULT, 0), \
611 LINE(BLAME_ID, "", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
612 LINE(BLAME_LINENO, "", COLOR_CYAN, COLOR_DEFAULT, 0)
615 #define LINE(type, line, fg, bg, attr) \
622 const char *name; /* Option name. */
623 int namelen; /* Size of option name. */
624 const char *line; /* The start of line to match. */
625 int linelen; /* Size of string to match. */
626 int fg, bg, attr; /* Color and text attributes for the lines. */
629 static struct line_info line_info[] = {
630 #define LINE(type, line, fg, bg, attr) \
631 { #type, STRING_SIZE(#type), (line), STRING_SIZE(line), (fg), (bg), (attr) }
636 static enum line_type
637 get_line_type(char *line)
639 int linelen = strlen(line);
642 for (type = 0; type < ARRAY_SIZE(line_info); type++)
643 /* Case insensitive search matches Signed-off-by lines better. */
644 if (linelen >= line_info[type].linelen &&
645 !strncasecmp(line_info[type].line, line, line_info[type].linelen))
652 get_line_attr(enum line_type type)
654 assert(type < ARRAY_SIZE(line_info));
655 return COLOR_PAIR(type) | line_info[type].attr;
658 static struct line_info *
659 get_line_info(char *name)
661 size_t namelen = strlen(name);
664 for (type = 0; type < ARRAY_SIZE(line_info); type++)
665 if (namelen == line_info[type].namelen &&
666 !string_enum_compare(line_info[type].name, name, namelen))
667 return &line_info[type];
675 int default_bg = line_info[LINE_DEFAULT].bg;
676 int default_fg = line_info[LINE_DEFAULT].fg;
681 if (assume_default_colors(default_fg, default_bg) == ERR) {
682 default_bg = COLOR_BLACK;
683 default_fg = COLOR_WHITE;
686 for (type = 0; type < ARRAY_SIZE(line_info); type++) {
687 struct line_info *info = &line_info[type];
688 int bg = info->bg == COLOR_DEFAULT ? default_bg : info->bg;
689 int fg = info->fg == COLOR_DEFAULT ? default_fg : info->fg;
691 init_pair(type, fg, bg);
699 unsigned int selected:1;
700 unsigned int dirty:1;
702 void *data; /* User data */
712 enum request request;
713 struct keybinding *next;
716 static struct keybinding default_keybindings[] = {
718 { 'm', REQ_VIEW_MAIN },
719 { 'd', REQ_VIEW_DIFF },
720 { 'l', REQ_VIEW_LOG },
721 { 't', REQ_VIEW_TREE },
722 { 'f', REQ_VIEW_BLOB },
723 { 'B', REQ_VIEW_BLAME },
724 { 'p', REQ_VIEW_PAGER },
725 { 'h', REQ_VIEW_HELP },
726 { 'S', REQ_VIEW_STATUS },
727 { 'c', REQ_VIEW_STAGE },
729 /* View manipulation */
730 { 'q', REQ_VIEW_CLOSE },
731 { KEY_TAB, REQ_VIEW_NEXT },
732 { KEY_RETURN, REQ_ENTER },
733 { KEY_UP, REQ_PREVIOUS },
734 { KEY_DOWN, REQ_NEXT },
735 { 'R', REQ_REFRESH },
737 /* Cursor navigation */
738 { 'k', REQ_MOVE_UP },
739 { 'j', REQ_MOVE_DOWN },
740 { KEY_HOME, REQ_MOVE_FIRST_LINE },
741 { KEY_END, REQ_MOVE_LAST_LINE },
742 { KEY_NPAGE, REQ_MOVE_PAGE_DOWN },
743 { ' ', REQ_MOVE_PAGE_DOWN },
744 { KEY_PPAGE, REQ_MOVE_PAGE_UP },
745 { 'b', REQ_MOVE_PAGE_UP },
746 { '-', REQ_MOVE_PAGE_UP },
749 { KEY_IC, REQ_SCROLL_LINE_UP },
750 { KEY_DC, REQ_SCROLL_LINE_DOWN },
751 { 'w', REQ_SCROLL_PAGE_UP },
752 { 's', REQ_SCROLL_PAGE_DOWN },
756 { '?', REQ_SEARCH_BACK },
757 { 'n', REQ_FIND_NEXT },
758 { 'N', REQ_FIND_PREV },
762 { 'z', REQ_STOP_LOADING },
763 { 'v', REQ_SHOW_VERSION },
764 { 'r', REQ_SCREEN_REDRAW },
765 { '.', REQ_TOGGLE_LINENO },
766 { 'D', REQ_TOGGLE_DATE },
767 { 'A', REQ_TOGGLE_AUTHOR },
768 { 'g', REQ_TOGGLE_REV_GRAPH },
769 { 'F', REQ_TOGGLE_REFS },
771 { 'u', REQ_STATUS_UPDATE },
772 { 'M', REQ_STATUS_MERGE },
773 { ',', REQ_TREE_PARENT },
776 /* Using the ncurses SIGWINCH handler. */
777 { KEY_RESIZE, REQ_SCREEN_RESIZE },
780 #define KEYMAP_INFO \
794 #define KEYMAP_(name) KEYMAP_##name
799 static struct int_map keymap_table[] = {
800 #define KEYMAP_(name) { #name, STRING_SIZE(#name), KEYMAP_##name }
805 #define set_keymap(map, name) \
806 set_from_int_map(keymap_table, ARRAY_SIZE(keymap_table), map, name, strlen(name))
808 static struct keybinding *keybindings[ARRAY_SIZE(keymap_table)];
811 add_keybinding(enum keymap keymap, enum request request, int key)
813 struct keybinding *keybinding;
815 keybinding = calloc(1, sizeof(*keybinding));
817 die("Failed to allocate keybinding");
819 keybinding->alias = key;
820 keybinding->request = request;
821 keybinding->next = keybindings[keymap];
822 keybindings[keymap] = keybinding;
825 /* Looks for a key binding first in the given map, then in the generic map, and
826 * lastly in the default keybindings. */
828 get_keybinding(enum keymap keymap, int key)
830 struct keybinding *kbd;
833 for (kbd = keybindings[keymap]; kbd; kbd = kbd->next)
834 if (kbd->alias == key)
837 for (kbd = keybindings[KEYMAP_GENERIC]; kbd; kbd = kbd->next)
838 if (kbd->alias == key)
841 for (i = 0; i < ARRAY_SIZE(default_keybindings); i++)
842 if (default_keybindings[i].alias == key)
843 return default_keybindings[i].request;
845 return (enum request) key;
854 static struct key key_table[] = {
855 { "Enter", KEY_RETURN },
857 { "Backspace", KEY_BACKSPACE },
859 { "Escape", KEY_ESC },
860 { "Left", KEY_LEFT },
861 { "Right", KEY_RIGHT },
863 { "Down", KEY_DOWN },
864 { "Insert", KEY_IC },
865 { "Delete", KEY_DC },
867 { "Home", KEY_HOME },
869 { "PageUp", KEY_PPAGE },
870 { "PageDown", KEY_NPAGE },
880 { "F10", KEY_F(10) },
881 { "F11", KEY_F(11) },
882 { "F12", KEY_F(12) },
886 get_key_value(const char *name)
890 for (i = 0; i < ARRAY_SIZE(key_table); i++)
891 if (!strcasecmp(key_table[i].name, name))
892 return key_table[i].value;
894 if (strlen(name) == 1 && isprint(*name))
901 get_key_name(int key_value)
903 static char key_char[] = "'X'";
907 for (key = 0; key < ARRAY_SIZE(key_table); key++)
908 if (key_table[key].value == key_value)
909 seq = key_table[key].name;
913 isprint(key_value)) {
914 key_char[1] = (char) key_value;
918 return seq ? seq : "'?'";
922 get_key(enum request request)
924 static char buf[BUFSIZ];
931 for (i = 0; i < ARRAY_SIZE(default_keybindings); i++) {
932 struct keybinding *keybinding = &default_keybindings[i];
934 if (keybinding->request != request)
937 if (!string_format_from(buf, &pos, "%s%s", sep,
938 get_key_name(keybinding->alias)))
939 return "Too many keybindings!";
949 char cmd[SIZEOF_STR];
952 static struct run_request *run_request;
953 static size_t run_requests;
956 add_run_request(enum keymap keymap, int key, int argc, char **argv)
958 struct run_request *tmp;
959 struct run_request req = { keymap, key };
962 for (bufpos = 0; argc > 0; argc--, argv++)
963 if (!string_format_from(req.cmd, &bufpos, "%s ", *argv))
966 req.cmd[bufpos - 1] = 0;
968 tmp = realloc(run_request, (run_requests + 1) * sizeof(*run_request));
973 run_request[run_requests++] = req;
975 return REQ_NONE + run_requests;
978 static struct run_request *
979 get_run_request(enum request request)
981 if (request <= REQ_NONE)
983 return &run_request[request - REQ_NONE - 1];
987 add_builtin_run_requests(void)
994 { KEYMAP_MAIN, 'C', { "git cherry-pick %(commit)" } },
995 { KEYMAP_GENERIC, 'G', { "git gc" } },
999 for (i = 0; i < ARRAY_SIZE(reqs); i++) {
1002 req = add_run_request(reqs[i].keymap, reqs[i].key, 1, reqs[i].argv);
1003 if (req != REQ_NONE)
1004 add_keybinding(reqs[i].keymap, req, reqs[i].key);
1009 * User config file handling.
1012 static struct int_map color_map[] = {
1013 #define COLOR_MAP(name) { #name, STRING_SIZE(#name), COLOR_##name }
1025 #define set_color(color, name) \
1026 set_from_int_map(color_map, ARRAY_SIZE(color_map), color, name, strlen(name))
1028 static struct int_map attr_map[] = {
1029 #define ATTR_MAP(name) { #name, STRING_SIZE(#name), A_##name }
1036 ATTR_MAP(UNDERLINE),
1039 #define set_attribute(attr, name) \
1040 set_from_int_map(attr_map, ARRAY_SIZE(attr_map), attr, name, strlen(name))
1042 static int config_lineno;
1043 static bool config_errors;
1044 static char *config_msg;
1046 /* Wants: object fgcolor bgcolor [attr] */
1048 option_color_command(int argc, char *argv[])
1050 struct line_info *info;
1052 if (argc != 3 && argc != 4) {
1053 config_msg = "Wrong number of arguments given to color command";
1057 info = get_line_info(argv[0]);
1059 if (!string_enum_compare(argv[0], "main-delim", strlen("main-delim"))) {
1060 info = get_line_info("delimiter");
1063 config_msg = "Unknown color name";
1068 if (set_color(&info->fg, argv[1]) == ERR ||
1069 set_color(&info->bg, argv[2]) == ERR) {
1070 config_msg = "Unknown color";
1074 if (argc == 4 && set_attribute(&info->attr, argv[3]) == ERR) {
1075 config_msg = "Unknown attribute";
1082 static bool parse_bool(const char *s)
1084 return (!strcmp(s, "1") || !strcmp(s, "true") ||
1085 !strcmp(s, "yes")) ? TRUE : FALSE;
1088 /* Wants: name = value */
1090 option_set_command(int argc, char *argv[])
1093 config_msg = "Wrong number of arguments given to set command";
1097 if (strcmp(argv[1], "=")) {
1098 config_msg = "No value assigned";
1102 if (!strcmp(argv[0], "show-author")) {
1103 opt_author = parse_bool(argv[2]);
1107 if (!strcmp(argv[0], "show-date")) {
1108 opt_date = parse_bool(argv[2]);
1112 if (!strcmp(argv[0], "show-rev-graph")) {
1113 opt_rev_graph = parse_bool(argv[2]);
1117 if (!strcmp(argv[0], "show-refs")) {
1118 opt_show_refs = parse_bool(argv[2]);
1122 if (!strcmp(argv[0], "show-line-numbers")) {
1123 opt_line_number = parse_bool(argv[2]);
1127 if (!strcmp(argv[0], "line-number-interval")) {
1128 opt_num_interval = atoi(argv[2]);
1132 if (!strcmp(argv[0], "tab-size")) {
1133 opt_tab_size = atoi(argv[2]);
1137 if (!strcmp(argv[0], "commit-encoding")) {
1138 char *arg = argv[2];
1139 int delimiter = *arg;
1142 switch (delimiter) {
1145 for (arg++, i = 0; arg[i]; i++)
1146 if (arg[i] == delimiter) {
1151 string_ncopy(opt_encoding, arg, strlen(arg));
1156 config_msg = "Unknown variable name";
1160 /* Wants: mode request key */
1162 option_bind_command(int argc, char *argv[])
1164 enum request request;
1169 config_msg = "Wrong number of arguments given to bind command";
1173 if (set_keymap(&keymap, argv[0]) == ERR) {
1174 config_msg = "Unknown key map";
1178 key = get_key_value(argv[1]);
1180 config_msg = "Unknown key";
1184 request = get_request(argv[2]);
1185 if (request == REQ_NONE) {
1186 const char *obsolete[] = { "cherry-pick" };
1187 size_t namelen = strlen(argv[2]);
1190 for (i = 0; i < ARRAY_SIZE(obsolete); i++) {
1191 if (namelen == strlen(obsolete[i]) &&
1192 !string_enum_compare(obsolete[i], argv[2], namelen)) {
1193 config_msg = "Obsolete request name";
1198 if (request == REQ_NONE && *argv[2]++ == '!')
1199 request = add_run_request(keymap, key, argc - 2, argv + 2);
1200 if (request == REQ_NONE) {
1201 config_msg = "Unknown request name";
1205 add_keybinding(keymap, request, key);
1211 set_option(char *opt, char *value)
1218 while (argc < ARRAY_SIZE(argv) && (valuelen = strcspn(value, " \t"))) {
1219 argv[argc++] = value;
1222 /* Nothing more to tokenize or last available token. */
1223 if (!*value || argc >= ARRAY_SIZE(argv))
1227 while (isspace(*value))
1231 if (!strcmp(opt, "color"))
1232 return option_color_command(argc, argv);
1234 if (!strcmp(opt, "set"))
1235 return option_set_command(argc, argv);
1237 if (!strcmp(opt, "bind"))
1238 return option_bind_command(argc, argv);
1240 config_msg = "Unknown option command";
1245 read_option(char *opt, size_t optlen, char *value, size_t valuelen)
1250 config_msg = "Internal error";
1252 /* Check for comment markers, since read_properties() will
1253 * only ensure opt and value are split at first " \t". */
1254 optlen = strcspn(opt, "#");
1258 if (opt[optlen] != 0) {
1259 config_msg = "No option value";
1263 /* Look for comment endings in the value. */
1264 size_t len = strcspn(value, "#");
1266 if (len < valuelen) {
1268 value[valuelen] = 0;
1271 status = set_option(opt, value);
1274 if (status == ERR) {
1275 fprintf(stderr, "Error on line %d, near '%.*s': %s\n",
1276 config_lineno, (int) optlen, opt, config_msg);
1277 config_errors = TRUE;
1280 /* Always keep going if errors are encountered. */
1285 load_option_file(const char *path)
1289 /* It's ok that the file doesn't exist. */
1290 file = fopen(path, "r");
1295 config_errors = FALSE;
1297 if (read_properties(file, " \t", read_option) == ERR ||
1298 config_errors == TRUE)
1299 fprintf(stderr, "Errors while loading %s.\n", path);
1305 char *home = getenv("HOME");
1306 char *tigrc_user = getenv("TIGRC_USER");
1307 char *tigrc_system = getenv("TIGRC_SYSTEM");
1308 char buf[SIZEOF_STR];
1310 add_builtin_run_requests();
1312 if (!tigrc_system) {
1313 if (!string_format(buf, "%s/tigrc", SYSCONFDIR))
1317 load_option_file(tigrc_system);
1320 if (!home || !string_format(buf, "%s/.tigrc", home))
1324 load_option_file(tigrc_user);
1337 /* The display array of active views and the index of the current view. */
1338 static struct view *display[2];
1339 static unsigned int current_view;
1341 /* Reading from the prompt? */
1342 static bool input_mode = FALSE;
1344 #define foreach_displayed_view(view, i) \
1345 for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
1347 #define displayed_views() (display[1] != NULL ? 2 : 1)
1349 /* Current head and commit ID */
1350 static char ref_blob[SIZEOF_REF] = "";
1351 static char ref_commit[SIZEOF_REF] = "HEAD";
1352 static char ref_head[SIZEOF_REF] = "HEAD";
1355 const char *name; /* View name */
1356 const char *cmd_fmt; /* Default command line format */
1357 const char *cmd_env; /* Command line set via environment */
1358 const char *id; /* Points to either of ref_{head,commit,blob} */
1360 struct view_ops *ops; /* View operations */
1362 enum keymap keymap; /* What keymap does this view have */
1363 bool git_dir; /* Whether the view requires a git directory. */
1365 char cmd[SIZEOF_STR]; /* Command buffer */
1366 char ref[SIZEOF_REF]; /* Hovered commit reference */
1367 char vid[SIZEOF_REF]; /* View ID. Set to id member when updating. */
1369 int height, width; /* The width and height of the main window */
1370 WINDOW *win; /* The main window */
1371 WINDOW *title; /* The title window living below the main window */
1374 unsigned long offset; /* Offset of the window top */
1375 unsigned long lineno; /* Current line number */
1378 char grep[SIZEOF_STR]; /* Search string */
1379 regex_t *regex; /* Pre-compiled regex */
1381 /* If non-NULL, points to the view that opened this view. If this view
1382 * is closed tig will switch back to the parent view. */
1383 struct view *parent;
1386 size_t lines; /* Total number of lines */
1387 struct line *line; /* Line index */
1388 size_t line_alloc; /* Total number of allocated lines */
1389 size_t line_size; /* Total number of used lines */
1390 unsigned int digits; /* Number of digits in the lines member. */
1398 /* What type of content being displayed. Used in the title bar. */
1400 /* Open and reads in all view content. */
1401 bool (*open)(struct view *view);
1402 /* Read one line; updates view->line. */
1403 bool (*read)(struct view *view, char *data);
1404 /* Draw one line; @lineno must be < view->height. */
1405 bool (*draw)(struct view *view, struct line *line, unsigned int lineno, bool selected);
1406 /* Depending on view handle a special requests. */
1407 enum request (*request)(struct view *view, enum request request, struct line *line);
1408 /* Search for regex in a line. */
1409 bool (*grep)(struct view *view, struct line *line);
1411 void (*select)(struct view *view, struct line *line);
1414 static struct view_ops pager_ops;
1415 static struct view_ops main_ops;
1416 static struct view_ops tree_ops;
1417 static struct view_ops blob_ops;
1418 static struct view_ops blame_ops;
1419 static struct view_ops help_ops;
1420 static struct view_ops status_ops;
1421 static struct view_ops stage_ops;
1423 #define VIEW_STR(name, cmd, env, ref, ops, map, git) \
1424 { name, cmd, #env, ref, ops, map, git }
1426 #define VIEW_(id, name, ops, git, ref) \
1427 VIEW_STR(name, TIG_##id##_CMD, TIG_##id##_CMD, ref, ops, KEYMAP_##id, git)
1430 static struct view views[] = {
1431 VIEW_(MAIN, "main", &main_ops, TRUE, ref_head),
1432 VIEW_(DIFF, "diff", &pager_ops, TRUE, ref_commit),
1433 VIEW_(LOG, "log", &pager_ops, TRUE, ref_head),
1434 VIEW_(TREE, "tree", &tree_ops, TRUE, ref_commit),
1435 VIEW_(BLOB, "blob", &blob_ops, TRUE, ref_blob),
1436 VIEW_(BLAME, "blame", &blame_ops, TRUE, ref_commit),
1437 VIEW_(HELP, "help", &help_ops, FALSE, ""),
1438 VIEW_(PAGER, "pager", &pager_ops, FALSE, "stdin"),
1439 VIEW_(STATUS, "status", &status_ops, TRUE, ""),
1440 VIEW_(STAGE, "stage", &stage_ops, TRUE, ""),
1443 #define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
1445 #define foreach_view(view, i) \
1446 for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
1448 #define view_is_displayed(view) \
1449 (view == display[0] || view == display[1])
1452 draw_text(struct view *view, const char *string, int max_len,
1453 bool use_tilde, bool selected)
1456 int trimmed = FALSE;
1462 len = utf8_length(string, max_len, &trimmed, use_tilde);
1464 len = strlen(string);
1465 if (len > max_len) {
1474 waddnstr(view->win, string, len);
1475 if (trimmed && use_tilde) {
1477 wattrset(view->win, get_line_attr(LINE_DELIMITER));
1478 waddch(view->win, '~');
1486 draw_view_line(struct view *view, unsigned int lineno)
1489 bool selected = (view->offset + lineno == view->lineno);
1492 assert(view_is_displayed(view));
1494 if (view->offset + lineno >= view->lines)
1497 line = &view->line[view->offset + lineno];
1500 line->selected = TRUE;
1501 view->ops->select(view, line);
1502 } else if (line->selected) {
1503 line->selected = FALSE;
1504 wmove(view->win, lineno, 0);
1505 wclrtoeol(view->win);
1508 scrollok(view->win, FALSE);
1509 draw_ok = view->ops->draw(view, line, lineno, selected);
1510 scrollok(view->win, TRUE);
1516 redraw_view_dirty(struct view *view)
1521 for (lineno = 0; lineno < view->height; lineno++) {
1522 struct line *line = &view->line[view->offset + lineno];
1528 if (!draw_view_line(view, lineno))
1534 redrawwin(view->win);
1536 wnoutrefresh(view->win);
1538 wrefresh(view->win);
1542 redraw_view_from(struct view *view, int lineno)
1544 assert(0 <= lineno && lineno < view->height);
1546 for (; lineno < view->height; lineno++) {
1547 if (!draw_view_line(view, lineno))
1551 redrawwin(view->win);
1553 wnoutrefresh(view->win);
1555 wrefresh(view->win);
1559 redraw_view(struct view *view)
1562 redraw_view_from(view, 0);
1567 update_view_title(struct view *view)
1569 char buf[SIZEOF_STR];
1570 char state[SIZEOF_STR];
1571 size_t bufpos = 0, statelen = 0;
1573 assert(view_is_displayed(view));
1575 if (view != VIEW(REQ_VIEW_STATUS) && (view->lines || view->pipe)) {
1576 unsigned int view_lines = view->offset + view->height;
1577 unsigned int lines = view->lines
1578 ? MIN(view_lines, view->lines) * 100 / view->lines
1581 string_format_from(state, &statelen, "- %s %d of %d (%d%%)",
1588 time_t secs = time(NULL) - view->start_time;
1590 /* Three git seconds are a long time ... */
1592 string_format_from(state, &statelen, " %lds", secs);
1596 string_format_from(buf, &bufpos, "[%s]", view->name);
1597 if (*view->ref && bufpos < view->width) {
1598 size_t refsize = strlen(view->ref);
1599 size_t minsize = bufpos + 1 + /* abbrev= */ 7 + 1 + statelen;
1601 if (minsize < view->width)
1602 refsize = view->width - minsize + 7;
1603 string_format_from(buf, &bufpos, " %.*s", (int) refsize, view->ref);
1606 if (statelen && bufpos < view->width) {
1607 string_format_from(buf, &bufpos, " %s", state);
1610 if (view == display[current_view])
1611 wbkgdset(view->title, get_line_attr(LINE_TITLE_FOCUS));
1613 wbkgdset(view->title, get_line_attr(LINE_TITLE_BLUR));
1615 mvwaddnstr(view->title, 0, 0, buf, bufpos);
1616 wclrtoeol(view->title);
1617 wmove(view->title, 0, view->width - 1);
1620 wnoutrefresh(view->title);
1622 wrefresh(view->title);
1626 resize_display(void)
1629 struct view *base = display[0];
1630 struct view *view = display[1] ? display[1] : display[0];
1632 /* Setup window dimensions */
1634 getmaxyx(stdscr, base->height, base->width);
1636 /* Make room for the status window. */
1640 /* Horizontal split. */
1641 view->width = base->width;
1642 view->height = SCALE_SPLIT_VIEW(base->height);
1643 base->height -= view->height;
1645 /* Make room for the title bar. */
1649 /* Make room for the title bar. */
1654 foreach_displayed_view (view, i) {
1656 view->win = newwin(view->height, 0, offset, 0);
1658 die("Failed to create %s view", view->name);
1660 scrollok(view->win, TRUE);
1662 view->title = newwin(1, 0, offset + view->height, 0);
1664 die("Failed to create title window");
1667 wresize(view->win, view->height, view->width);
1668 mvwin(view->win, offset, 0);
1669 mvwin(view->title, offset + view->height, 0);
1672 offset += view->height + 1;
1677 redraw_display(void)
1682 foreach_displayed_view (view, i) {
1684 update_view_title(view);
1689 update_display_cursor(struct view *view)
1691 /* Move the cursor to the right-most column of the cursor line.
1693 * XXX: This could turn out to be a bit expensive, but it ensures that
1694 * the cursor does not jump around. */
1696 wmove(view->win, view->lineno - view->offset, view->width - 1);
1697 wrefresh(view->win);
1705 /* Scrolling backend */
1707 do_scroll_view(struct view *view, int lines)
1709 bool redraw_current_line = FALSE;
1711 /* The rendering expects the new offset. */
1712 view->offset += lines;
1714 assert(0 <= view->offset && view->offset < view->lines);
1717 /* Move current line into the view. */
1718 if (view->lineno < view->offset) {
1719 view->lineno = view->offset;
1720 redraw_current_line = TRUE;
1721 } else if (view->lineno >= view->offset + view->height) {
1722 view->lineno = view->offset + view->height - 1;
1723 redraw_current_line = TRUE;
1726 assert(view->offset <= view->lineno && view->lineno < view->lines);
1728 /* Redraw the whole screen if scrolling is pointless. */
1729 if (view->height < ABS(lines)) {
1733 int line = lines > 0 ? view->height - lines : 0;
1734 int end = line + ABS(lines);
1736 wscrl(view->win, lines);
1738 for (; line < end; line++) {
1739 if (!draw_view_line(view, line))
1743 if (redraw_current_line)
1744 draw_view_line(view, view->lineno - view->offset);
1747 redrawwin(view->win);
1748 wrefresh(view->win);
1752 /* Scroll frontend */
1754 scroll_view(struct view *view, enum request request)
1758 assert(view_is_displayed(view));
1761 case REQ_SCROLL_PAGE_DOWN:
1762 lines = view->height;
1763 case REQ_SCROLL_LINE_DOWN:
1764 if (view->offset + lines > view->lines)
1765 lines = view->lines - view->offset;
1767 if (lines == 0 || view->offset + view->height >= view->lines) {
1768 report("Cannot scroll beyond the last line");
1773 case REQ_SCROLL_PAGE_UP:
1774 lines = view->height;
1775 case REQ_SCROLL_LINE_UP:
1776 if (lines > view->offset)
1777 lines = view->offset;
1780 report("Cannot scroll beyond the first line");
1788 die("request %d not handled in switch", request);
1791 do_scroll_view(view, lines);
1796 move_view(struct view *view, enum request request)
1798 int scroll_steps = 0;
1802 case REQ_MOVE_FIRST_LINE:
1803 steps = -view->lineno;
1806 case REQ_MOVE_LAST_LINE:
1807 steps = view->lines - view->lineno - 1;
1810 case REQ_MOVE_PAGE_UP:
1811 steps = view->height > view->lineno
1812 ? -view->lineno : -view->height;
1815 case REQ_MOVE_PAGE_DOWN:
1816 steps = view->lineno + view->height >= view->lines
1817 ? view->lines - view->lineno - 1 : view->height;
1829 die("request %d not handled in switch", request);
1832 if (steps <= 0 && view->lineno == 0) {
1833 report("Cannot move beyond the first line");
1836 } else if (steps >= 0 && view->lineno + 1 >= view->lines) {
1837 report("Cannot move beyond the last line");
1841 /* Move the current line */
1842 view->lineno += steps;
1843 assert(0 <= view->lineno && view->lineno < view->lines);
1845 /* Check whether the view needs to be scrolled */
1846 if (view->lineno < view->offset ||
1847 view->lineno >= view->offset + view->height) {
1848 scroll_steps = steps;
1849 if (steps < 0 && -steps > view->offset) {
1850 scroll_steps = -view->offset;
1852 } else if (steps > 0) {
1853 if (view->lineno == view->lines - 1 &&
1854 view->lines > view->height) {
1855 scroll_steps = view->lines - view->offset - 1;
1856 if (scroll_steps >= view->height)
1857 scroll_steps -= view->height - 1;
1862 if (!view_is_displayed(view)) {
1863 view->offset += scroll_steps;
1864 assert(0 <= view->offset && view->offset < view->lines);
1865 view->ops->select(view, &view->line[view->lineno]);
1869 /* Repaint the old "current" line if we be scrolling */
1870 if (ABS(steps) < view->height)
1871 draw_view_line(view, view->lineno - steps - view->offset);
1874 do_scroll_view(view, scroll_steps);
1878 /* Draw the current line */
1879 draw_view_line(view, view->lineno - view->offset);
1881 redrawwin(view->win);
1882 wrefresh(view->win);
1891 static void search_view(struct view *view, enum request request);
1894 find_next_line(struct view *view, unsigned long lineno, struct line *line)
1896 assert(view_is_displayed(view));
1898 if (!view->ops->grep(view, line))
1901 if (lineno - view->offset >= view->height) {
1902 view->offset = lineno;
1903 view->lineno = lineno;
1907 unsigned long old_lineno = view->lineno - view->offset;
1909 view->lineno = lineno;
1910 draw_view_line(view, old_lineno);
1912 draw_view_line(view, view->lineno - view->offset);
1913 redrawwin(view->win);
1914 wrefresh(view->win);
1917 report("Line %ld matches '%s'", lineno + 1, view->grep);
1922 find_next(struct view *view, enum request request)
1924 unsigned long lineno = view->lineno;
1929 report("No previous search");
1931 search_view(view, request);
1941 case REQ_SEARCH_BACK:
1950 if (request == REQ_FIND_NEXT || request == REQ_FIND_PREV)
1951 lineno += direction;
1953 /* Note, lineno is unsigned long so will wrap around in which case it
1954 * will become bigger than view->lines. */
1955 for (; lineno < view->lines; lineno += direction) {
1956 struct line *line = &view->line[lineno];
1958 if (find_next_line(view, lineno, line))
1962 report("No match found for '%s'", view->grep);
1966 search_view(struct view *view, enum request request)
1971 regfree(view->regex);
1974 view->regex = calloc(1, sizeof(*view->regex));
1979 regex_err = regcomp(view->regex, opt_search, REG_EXTENDED);
1980 if (regex_err != 0) {
1981 char buf[SIZEOF_STR] = "unknown error";
1983 regerror(regex_err, view->regex, buf, sizeof(buf));
1984 report("Search failed: %s", buf);
1988 string_copy(view->grep, opt_search);
1990 find_next(view, request);
1994 * Incremental updating
1998 end_update(struct view *view)
2002 set_nonblocking_input(FALSE);
2003 if (view->pipe == stdin)
2011 begin_update(struct view *view)
2017 string_copy(view->cmd, opt_cmd);
2019 /* When running random commands, initially show the
2020 * command in the title. However, it maybe later be
2021 * overwritten if a commit line is selected. */
2022 if (view == VIEW(REQ_VIEW_PAGER))
2023 string_copy(view->ref, view->cmd);
2027 } else if (view == VIEW(REQ_VIEW_TREE)) {
2028 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
2029 char path[SIZEOF_STR];
2031 if (strcmp(view->vid, view->id))
2032 opt_path[0] = path[0] = 0;
2033 else if (sq_quote(path, 0, opt_path) >= sizeof(path))
2036 if (!string_format(view->cmd, format, view->id, path))
2040 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
2041 const char *id = view->id;
2043 if (!string_format(view->cmd, format, id, id, id, id, id))
2046 /* Put the current ref_* value to the view title ref
2047 * member. This is needed by the blob view. Most other
2048 * views sets it automatically after loading because the
2049 * first line is a commit line. */
2050 string_copy_rev(view->ref, view->id);
2053 /* Special case for the pager view. */
2055 view->pipe = opt_pipe;
2058 view->pipe = popen(view->cmd, "r");
2064 set_nonblocking_input(TRUE);
2069 string_copy_rev(view->vid, view->id);
2074 for (i = 0; i < view->lines; i++)
2075 if (view->line[i].data)
2076 free(view->line[i].data);
2082 view->start_time = time(NULL);
2087 #define ITEM_CHUNK_SIZE 256
2089 realloc_items(void *mem, size_t *size, size_t new_size, size_t item_size)
2091 size_t num_chunks = *size / ITEM_CHUNK_SIZE;
2092 size_t num_chunks_new = (new_size + ITEM_CHUNK_SIZE - 1) / ITEM_CHUNK_SIZE;
2094 if (mem == NULL || num_chunks != num_chunks_new) {
2095 *size = num_chunks_new * ITEM_CHUNK_SIZE;
2096 mem = realloc(mem, *size * item_size);
2102 static struct line *
2103 realloc_lines(struct view *view, size_t line_size)
2105 size_t alloc = view->line_alloc;
2106 struct line *tmp = realloc_items(view->line, &alloc, line_size,
2107 sizeof(*view->line));
2113 view->line_alloc = alloc;
2114 view->line_size = line_size;
2119 update_view(struct view *view)
2121 char in_buffer[BUFSIZ];
2122 char out_buffer[BUFSIZ * 2];
2124 /* The number of lines to read. If too low it will cause too much
2125 * redrawing (and possible flickering), if too high responsiveness
2127 unsigned long lines = view->height;
2128 int redraw_from = -1;
2133 /* Only redraw if lines are visible. */
2134 if (view->offset + view->height >= view->lines)
2135 redraw_from = view->lines - view->offset;
2137 /* FIXME: This is probably not perfect for backgrounded views. */
2138 if (!realloc_lines(view, view->lines + lines))
2141 while ((line = fgets(in_buffer, sizeof(in_buffer), view->pipe))) {
2142 size_t linelen = strlen(line);
2145 line[linelen - 1] = 0;
2147 if (opt_iconv != ICONV_NONE) {
2148 ICONV_CONST char *inbuf = line;
2149 size_t inlen = linelen;
2151 char *outbuf = out_buffer;
2152 size_t outlen = sizeof(out_buffer);
2156 ret = iconv(opt_iconv, &inbuf, &inlen, &outbuf, &outlen);
2157 if (ret != (size_t) -1) {
2159 linelen = strlen(out_buffer);
2163 if (!view->ops->read(view, line))
2173 lines = view->lines;
2174 for (digits = 0; lines; digits++)
2177 /* Keep the displayed view in sync with line number scaling. */
2178 if (digits != view->digits) {
2179 view->digits = digits;
2184 if (!view_is_displayed(view))
2187 if (view == VIEW(REQ_VIEW_TREE)) {
2188 /* Clear the view and redraw everything since the tree sorting
2189 * might have rearranged things. */
2192 } else if (redraw_from >= 0) {
2193 /* If this is an incremental update, redraw the previous line
2194 * since for commits some members could have changed when
2195 * loading the main view. */
2196 if (redraw_from > 0)
2199 /* Since revision graph visualization requires knowledge
2200 * about the parent commit, it causes a further one-off
2201 * needed to be redrawn for incremental updates. */
2202 if (redraw_from > 0 && opt_rev_graph)
2205 /* Incrementally draw avoids flickering. */
2206 redraw_view_from(view, redraw_from);
2209 if (view == VIEW(REQ_VIEW_BLAME))
2210 redraw_view_dirty(view);
2212 /* Update the title _after_ the redraw so that if the redraw picks up a
2213 * commit reference in view->ref it'll be available here. */
2214 update_view_title(view);
2217 if (ferror(view->pipe)) {
2218 report("Failed to read: %s", strerror(errno));
2221 } else if (feof(view->pipe)) {
2229 report("Allocation failure");
2232 if (view->ops->read(view, NULL))
2237 static struct line *
2238 add_line_data(struct view *view, void *data, enum line_type type)
2240 struct line *line = &view->line[view->lines++];
2242 memset(line, 0, sizeof(*line));
2249 static struct line *
2250 add_line_text(struct view *view, char *data, enum line_type type)
2253 data = strdup(data);
2255 return data ? add_line_data(view, data, type) : NULL;
2264 OPEN_DEFAULT = 0, /* Use default view switching. */
2265 OPEN_SPLIT = 1, /* Split current view. */
2266 OPEN_BACKGROUNDED = 2, /* Backgrounded. */
2267 OPEN_RELOAD = 4, /* Reload view even if it is the current. */
2271 open_view(struct view *prev, enum request request, enum open_flags flags)
2273 bool backgrounded = !!(flags & OPEN_BACKGROUNDED);
2274 bool split = !!(flags & OPEN_SPLIT);
2275 bool reload = !!(flags & OPEN_RELOAD);
2276 struct view *view = VIEW(request);
2277 int nviews = displayed_views();
2278 struct view *base_view = display[0];
2280 if (view == prev && nviews == 1 && !reload) {
2281 report("Already in %s view", view->name);
2285 if (view->git_dir && !opt_git_dir[0]) {
2286 report("The %s view is disabled in pager view", view->name);
2295 /* Maximize the current view. */
2296 memset(display, 0, sizeof(display));
2298 display[current_view] = view;
2301 /* Resize the view when switching between split- and full-screen,
2302 * or when switching between two different full-screen views. */
2303 if (nviews != displayed_views() ||
2304 (nviews == 1 && base_view != display[0]))
2307 if (view->ops->open) {
2308 if (!view->ops->open(view)) {
2309 report("Failed to load %s view", view->name);
2313 } else if ((reload || strcmp(view->vid, view->id)) &&
2314 !begin_update(view)) {
2315 report("Failed to load %s view", view->name);
2319 if (split && prev->lineno - prev->offset >= prev->height) {
2320 /* Take the title line into account. */
2321 int lines = prev->lineno - prev->offset - prev->height + 1;
2323 /* Scroll the view that was split if the current line is
2324 * outside the new limited view. */
2325 do_scroll_view(prev, lines);
2328 if (prev && view != prev) {
2329 if (split && !backgrounded) {
2330 /* "Blur" the previous view. */
2331 update_view_title(prev);
2334 view->parent = prev;
2337 if (view->pipe && view->lines == 0) {
2338 /* Clear the old view and let the incremental updating refill
2347 /* If the view is backgrounded the above calls to report()
2348 * won't redraw the view title. */
2350 update_view_title(view);
2354 open_external_viewer(const char *cmd)
2356 def_prog_mode(); /* save current tty modes */
2357 endwin(); /* restore original tty modes */
2359 fprintf(stderr, "Press Enter to continue");
2366 open_mergetool(const char *file)
2368 char cmd[SIZEOF_STR];
2369 char file_sq[SIZEOF_STR];
2371 if (sq_quote(file_sq, 0, file) < sizeof(file_sq) &&
2372 string_format(cmd, "git mergetool %s", file_sq)) {
2373 open_external_viewer(cmd);
2378 open_editor(bool from_root, const char *file)
2380 char cmd[SIZEOF_STR];
2381 char file_sq[SIZEOF_STR];
2383 char *prefix = from_root ? opt_cdup : "";
2385 editor = getenv("GIT_EDITOR");
2386 if (!editor && *opt_editor)
2387 editor = opt_editor;
2389 editor = getenv("VISUAL");
2391 editor = getenv("EDITOR");
2395 if (sq_quote(file_sq, 0, file) < sizeof(file_sq) &&
2396 string_format(cmd, "%s %s%s", editor, prefix, file_sq)) {
2397 open_external_viewer(cmd);
2402 open_run_request(enum request request)
2404 struct run_request *req = get_run_request(request);
2405 char buf[SIZEOF_STR * 2];
2410 report("Unknown run request");
2418 char *next = strstr(cmd, "%(");
2419 int len = next - cmd;
2426 } else if (!strncmp(next, "%(head)", 7)) {
2429 } else if (!strncmp(next, "%(commit)", 9)) {
2432 } else if (!strncmp(next, "%(blob)", 7)) {
2436 report("Unknown replacement in run request: `%s`", req->cmd);
2440 if (!string_format_from(buf, &bufpos, "%.*s%s", len, cmd, value))
2444 next = strchr(next, ')') + 1;
2448 open_external_viewer(buf);
2452 * User request switch noodle
2456 view_driver(struct view *view, enum request request)
2460 if (request == REQ_NONE) {
2465 if (request > REQ_NONE) {
2466 open_run_request(request);
2470 if (view && view->lines) {
2471 request = view->ops->request(view, request, &view->line[view->lineno]);
2472 if (request == REQ_NONE)
2479 case REQ_MOVE_PAGE_UP:
2480 case REQ_MOVE_PAGE_DOWN:
2481 case REQ_MOVE_FIRST_LINE:
2482 case REQ_MOVE_LAST_LINE:
2483 move_view(view, request);
2486 case REQ_SCROLL_LINE_DOWN:
2487 case REQ_SCROLL_LINE_UP:
2488 case REQ_SCROLL_PAGE_DOWN:
2489 case REQ_SCROLL_PAGE_UP:
2490 scroll_view(view, request);
2493 case REQ_VIEW_BLAME:
2495 report("No file chosen, press %s to open tree view",
2496 get_key(REQ_VIEW_TREE));
2499 open_view(view, request, OPEN_DEFAULT);
2504 report("No file chosen, press %s to open tree view",
2505 get_key(REQ_VIEW_TREE));
2508 open_view(view, request, OPEN_DEFAULT);
2511 case REQ_VIEW_PAGER:
2512 if (!opt_pipe && !VIEW(REQ_VIEW_PAGER)->lines) {
2513 report("No pager content, press %s to run command from prompt",
2514 get_key(REQ_PROMPT));
2517 open_view(view, request, OPEN_DEFAULT);
2520 case REQ_VIEW_STAGE:
2521 if (!VIEW(REQ_VIEW_STAGE)->lines) {
2522 report("No stage content, press %s to open the status view and choose file",
2523 get_key(REQ_VIEW_STATUS));
2526 open_view(view, request, OPEN_DEFAULT);
2529 case REQ_VIEW_STATUS:
2530 if (opt_is_inside_work_tree == FALSE) {
2531 report("The status view requires a working tree");
2534 open_view(view, request, OPEN_DEFAULT);
2542 open_view(view, request, OPEN_DEFAULT);
2547 request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
2549 if ((view == VIEW(REQ_VIEW_DIFF) &&
2550 view->parent == VIEW(REQ_VIEW_MAIN)) ||
2551 (view == VIEW(REQ_VIEW_DIFF) &&
2552 view->parent == VIEW(REQ_VIEW_BLAME)) ||
2553 (view == VIEW(REQ_VIEW_STAGE) &&
2554 view->parent == VIEW(REQ_VIEW_STATUS)) ||
2555 (view == VIEW(REQ_VIEW_BLOB) &&
2556 view->parent == VIEW(REQ_VIEW_TREE))) {
2559 view = view->parent;
2560 line = view->lineno;
2561 move_view(view, request);
2562 if (view_is_displayed(view))
2563 update_view_title(view);
2564 if (line != view->lineno)
2565 view->ops->request(view, REQ_ENTER,
2566 &view->line[view->lineno]);
2569 move_view(view, request);
2575 int nviews = displayed_views();
2576 int next_view = (current_view + 1) % nviews;
2578 if (next_view == current_view) {
2579 report("Only one view is displayed");
2583 current_view = next_view;
2584 /* Blur out the title of the previous view. */
2585 update_view_title(view);
2590 report("Refreshing is not yet supported for the %s view", view->name);
2593 case REQ_TOGGLE_LINENO:
2594 opt_line_number = !opt_line_number;
2598 case REQ_TOGGLE_DATE:
2599 opt_date = !opt_date;
2603 case REQ_TOGGLE_AUTHOR:
2604 opt_author = !opt_author;
2608 case REQ_TOGGLE_REV_GRAPH:
2609 opt_rev_graph = !opt_rev_graph;
2613 case REQ_TOGGLE_REFS:
2614 opt_show_refs = !opt_show_refs;
2619 /* Always reload^Wrerun commands from the prompt. */
2620 open_view(view, opt_request, OPEN_RELOAD);
2624 case REQ_SEARCH_BACK:
2625 search_view(view, request);
2630 find_next(view, request);
2633 case REQ_STOP_LOADING:
2634 for (i = 0; i < ARRAY_SIZE(views); i++) {
2637 report("Stopped loading the %s view", view->name),
2642 case REQ_SHOW_VERSION:
2643 report("tig-%s (built %s)", TIG_VERSION, __DATE__);
2646 case REQ_SCREEN_RESIZE:
2649 case REQ_SCREEN_REDRAW:
2654 report("Nothing to edit");
2659 report("Nothing to enter");
2663 case REQ_VIEW_CLOSE:
2664 /* XXX: Mark closed views by letting view->parent point to the
2665 * view itself. Parents to closed view should never be
2668 view->parent->parent != view->parent) {
2669 memset(display, 0, sizeof(display));
2671 display[current_view] = view->parent;
2672 view->parent = view;
2682 /* An unknown key will show most commonly used commands. */
2683 report("Unknown key, press 'h' for help");
2696 pager_draw(struct view *view, struct line *line, unsigned int lineno, bool selected)
2698 char *text = line->data;
2699 enum line_type type = line->type;
2702 wmove(view->win, lineno, 0);
2706 wchgat(view->win, -1, 0, type, NULL);
2709 attr = get_line_attr(type);
2710 wattrset(view->win, attr);
2712 if (opt_line_number || opt_tab_size < TABSIZE) {
2713 static char spaces[] = " ";
2714 int col_offset = 0, col = 0;
2716 if (opt_line_number) {
2717 unsigned long real_lineno = view->offset + lineno + 1;
2719 if (real_lineno == 1 ||
2720 (real_lineno % opt_num_interval) == 0) {
2721 wprintw(view->win, "%.*d", view->digits, real_lineno);
2724 waddnstr(view->win, spaces,
2725 MIN(view->digits, STRING_SIZE(spaces)));
2727 waddstr(view->win, ": ");
2728 col_offset = view->digits + 2;
2731 while (text && col_offset + col < view->width) {
2732 int cols_max = view->width - col_offset - col;
2736 if (*text == '\t') {
2738 assert(sizeof(spaces) > TABSIZE);
2740 cols = opt_tab_size - (col % opt_tab_size);
2743 text = strchr(text, '\t');
2744 cols = line ? text - pos : strlen(pos);
2747 waddnstr(view->win, pos, MIN(cols, cols_max));
2752 draw_text(view, text, view->width, TRUE, selected);
2759 add_describe_ref(char *buf, size_t *bufpos, char *commit_id, const char *sep)
2761 char refbuf[SIZEOF_STR];
2765 if (!string_format(refbuf, "git describe %s 2>/dev/null", commit_id))
2768 pipe = popen(refbuf, "r");
2772 if ((ref = fgets(refbuf, sizeof(refbuf), pipe)))
2773 ref = chomp_string(ref);
2779 /* This is the only fatal call, since it can "corrupt" the buffer. */
2780 if (!string_nformat(buf, SIZEOF_STR, bufpos, "%s%s", sep, ref))
2787 add_pager_refs(struct view *view, struct line *line)
2789 char buf[SIZEOF_STR];
2790 char *commit_id = (char *)line->data + STRING_SIZE("commit ");
2792 size_t bufpos = 0, refpos = 0;
2793 const char *sep = "Refs: ";
2794 bool is_tag = FALSE;
2796 assert(line->type == LINE_COMMIT);
2798 refs = get_refs(commit_id);
2800 if (view == VIEW(REQ_VIEW_DIFF))
2801 goto try_add_describe_ref;
2806 struct ref *ref = refs[refpos];
2807 char *fmt = ref->tag ? "%s[%s]" :
2808 ref->remote ? "%s<%s>" : "%s%s";
2810 if (!string_format_from(buf, &bufpos, fmt, sep, ref->name))
2815 } while (refs[refpos++]->next);
2817 if (!is_tag && view == VIEW(REQ_VIEW_DIFF)) {
2818 try_add_describe_ref:
2819 /* Add <tag>-g<commit_id> "fake" reference. */
2820 if (!add_describe_ref(buf, &bufpos, commit_id, sep))
2827 if (!realloc_lines(view, view->line_size + 1))
2830 add_line_text(view, buf, LINE_PP_REFS);
2834 pager_read(struct view *view, char *data)
2841 line = add_line_text(view, data, get_line_type(data));
2845 if (line->type == LINE_COMMIT &&
2846 (view == VIEW(REQ_VIEW_DIFF) ||
2847 view == VIEW(REQ_VIEW_LOG)))
2848 add_pager_refs(view, line);
2854 pager_request(struct view *view, enum request request, struct line *line)
2858 if (request != REQ_ENTER)
2861 if (line->type == LINE_COMMIT &&
2862 (view == VIEW(REQ_VIEW_LOG) ||
2863 view == VIEW(REQ_VIEW_PAGER))) {
2864 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
2868 /* Always scroll the view even if it was split. That way
2869 * you can use Enter to scroll through the log view and
2870 * split open each commit diff. */
2871 scroll_view(view, REQ_SCROLL_LINE_DOWN);
2873 /* FIXME: A minor workaround. Scrolling the view will call report("")
2874 * but if we are scrolling a non-current view this won't properly
2875 * update the view title. */
2877 update_view_title(view);
2883 pager_grep(struct view *view, struct line *line)
2886 char *text = line->data;
2891 if (regexec(view->regex, text, 1, &pmatch, 0) == REG_NOMATCH)
2898 pager_select(struct view *view, struct line *line)
2900 if (line->type == LINE_COMMIT) {
2901 char *text = (char *)line->data + STRING_SIZE("commit ");
2903 if (view != VIEW(REQ_VIEW_PAGER))
2904 string_copy_rev(view->ref, text);
2905 string_copy_rev(ref_commit, text);
2909 static struct view_ops pager_ops = {
2925 help_open(struct view *view)
2928 int lines = ARRAY_SIZE(req_info) + 2;
2931 if (view->lines > 0)
2934 for (i = 0; i < ARRAY_SIZE(req_info); i++)
2935 if (!req_info[i].request)
2938 lines += run_requests + 1;
2940 view->line = calloc(lines, sizeof(*view->line));
2944 add_line_text(view, "Quick reference for tig keybindings:", LINE_DEFAULT);
2946 for (i = 0; i < ARRAY_SIZE(req_info); i++) {
2949 if (req_info[i].request == REQ_NONE)
2952 if (!req_info[i].request) {
2953 add_line_text(view, "", LINE_DEFAULT);
2954 add_line_text(view, req_info[i].help, LINE_DEFAULT);
2958 key = get_key(req_info[i].request);
2960 key = "(no key defined)";
2962 if (!string_format(buf, " %-25s %s", key, req_info[i].help))
2965 add_line_text(view, buf, LINE_DEFAULT);
2969 add_line_text(view, "", LINE_DEFAULT);
2970 add_line_text(view, "External commands:", LINE_DEFAULT);
2973 for (i = 0; i < run_requests; i++) {
2974 struct run_request *req = get_run_request(REQ_NONE + i + 1);
2980 key = get_key_name(req->key);
2982 key = "(no key defined)";
2984 if (!string_format(buf, " %-10s %-14s `%s`",
2985 keymap_table[req->keymap].name,
2989 add_line_text(view, buf, LINE_DEFAULT);
2995 static struct view_ops help_ops = {
3010 struct tree_stack_entry {
3011 struct tree_stack_entry *prev; /* Entry below this in the stack */
3012 unsigned long lineno; /* Line number to restore */
3013 char *name; /* Position of name in opt_path */
3016 /* The top of the path stack. */
3017 static struct tree_stack_entry *tree_stack = NULL;
3018 unsigned long tree_lineno = 0;
3021 pop_tree_stack_entry(void)
3023 struct tree_stack_entry *entry = tree_stack;
3025 tree_lineno = entry->lineno;
3027 tree_stack = entry->prev;
3032 push_tree_stack_entry(char *name, unsigned long lineno)
3034 struct tree_stack_entry *entry = calloc(1, sizeof(*entry));
3035 size_t pathlen = strlen(opt_path);
3040 entry->prev = tree_stack;
3041 entry->name = opt_path + pathlen;
3044 if (!string_format_from(opt_path, &pathlen, "%s/", name)) {
3045 pop_tree_stack_entry();
3049 /* Move the current line to the first tree entry. */
3051 entry->lineno = lineno;
3054 /* Parse output from git-ls-tree(1):
3056 * 100644 blob fb0e31ea6cc679b7379631188190e975f5789c26 Makefile
3057 * 100644 blob 5304ca4260aaddaee6498f9630e7d471b8591ea6 README
3058 * 100644 blob f931e1d229c3e185caad4449bf5b66ed72462657 tig.c
3059 * 100644 blob ed09fe897f3c7c9af90bcf80cae92558ea88ae38 web.conf
3062 #define SIZEOF_TREE_ATTR \
3063 STRING_SIZE("100644 blob ed09fe897f3c7c9af90bcf80cae92558ea88ae38\t")
3065 #define TREE_UP_FORMAT "040000 tree %s\t.."
3068 tree_compare_entry(enum line_type type1, char *name1,
3069 enum line_type type2, char *name2)
3071 if (type1 != type2) {
3072 if (type1 == LINE_TREE_DIR)
3077 return strcmp(name1, name2);
3081 tree_path(struct line *line)
3083 char *path = line->data;
3085 return path + SIZEOF_TREE_ATTR;
3089 tree_read(struct view *view, char *text)
3091 size_t textlen = text ? strlen(text) : 0;
3092 char buf[SIZEOF_STR];
3094 enum line_type type;
3095 bool first_read = view->lines == 0;
3099 if (textlen <= SIZEOF_TREE_ATTR)
3102 type = text[STRING_SIZE("100644 ")] == 't'
3103 ? LINE_TREE_DIR : LINE_TREE_FILE;
3106 /* Add path info line */
3107 if (!string_format(buf, "Directory path /%s", opt_path) ||
3108 !realloc_lines(view, view->line_size + 1) ||
3109 !add_line_text(view, buf, LINE_DEFAULT))
3112 /* Insert "link" to parent directory. */
3114 if (!string_format(buf, TREE_UP_FORMAT, view->ref) ||
3115 !realloc_lines(view, view->line_size + 1) ||
3116 !add_line_text(view, buf, LINE_TREE_DIR))
3121 /* Strip the path part ... */
3123 size_t pathlen = textlen - SIZEOF_TREE_ATTR;
3124 size_t striplen = strlen(opt_path);
3125 char *path = text + SIZEOF_TREE_ATTR;
3127 if (pathlen > striplen)
3128 memmove(path, path + striplen,
3129 pathlen - striplen + 1);
3132 /* Skip "Directory ..." and ".." line. */
3133 for (pos = 1 + !!*opt_path; pos < view->lines; pos++) {
3134 struct line *line = &view->line[pos];
3135 char *path1 = tree_path(line);
3136 char *path2 = text + SIZEOF_TREE_ATTR;
3137 int cmp = tree_compare_entry(line->type, path1, type, path2);
3142 text = strdup(text);
3146 if (view->lines > pos)
3147 memmove(&view->line[pos + 1], &view->line[pos],
3148 (view->lines - pos) * sizeof(*line));
3150 line = &view->line[pos];
3157 if (!add_line_text(view, text, type))
3160 if (tree_lineno > view->lineno) {
3161 view->lineno = tree_lineno;
3169 tree_request(struct view *view, enum request request, struct line *line)
3171 enum open_flags flags;
3173 if (request == REQ_VIEW_BLAME) {
3174 char *filename = tree_path(line);
3176 if (line->type == LINE_TREE_DIR) {
3177 report("Cannot show blame for directory %s", opt_path);
3181 string_copy(opt_ref, view->vid);
3182 string_format(opt_file, "%s%s", opt_path, filename);
3185 if (request == REQ_TREE_PARENT) {
3188 request = REQ_ENTER;
3189 line = &view->line[1];
3191 /* quit view if at top of tree */
3192 return REQ_VIEW_CLOSE;
3195 if (request != REQ_ENTER)
3198 /* Cleanup the stack if the tree view is at a different tree. */
3199 while (!*opt_path && tree_stack)
3200 pop_tree_stack_entry();
3202 switch (line->type) {
3204 /* Depending on whether it is a subdir or parent (updir?) link
3205 * mangle the path buffer. */
3206 if (line == &view->line[1] && *opt_path) {
3207 pop_tree_stack_entry();
3210 char *basename = tree_path(line);
3212 push_tree_stack_entry(basename, view->lineno);
3215 /* Trees and subtrees share the same ID, so they are not not
3216 * unique like blobs. */
3217 flags = OPEN_RELOAD;
3218 request = REQ_VIEW_TREE;
3221 case LINE_TREE_FILE:
3222 flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
3223 request = REQ_VIEW_BLOB;
3230 open_view(view, request, flags);
3231 if (request == REQ_VIEW_TREE) {
3232 view->lineno = tree_lineno;
3239 tree_select(struct view *view, struct line *line)
3241 char *text = (char *)line->data + STRING_SIZE("100644 blob ");
3243 if (line->type == LINE_TREE_FILE) {
3244 string_copy_rev(ref_blob, text);
3246 } else if (line->type != LINE_TREE_DIR) {
3250 string_copy_rev(view->ref, text);
3253 static struct view_ops tree_ops = {
3264 blob_read(struct view *view, char *line)
3268 return add_line_text(view, line, LINE_DEFAULT) != NULL;
3271 static struct view_ops blob_ops = {
3284 * Loading the blame view is a two phase job:
3286 * 1. File content is read either using opt_file from the
3287 * filesystem or using git-cat-file.
3288 * 2. Then blame information is incrementally added by
3289 * reading output from git-blame.
3292 struct blame_commit {
3293 char id[SIZEOF_REV]; /* SHA1 ID. */
3294 char title[128]; /* First line of the commit message. */
3295 char author[75]; /* Author of the commit. */
3296 struct tm time; /* Date from the author ident. */
3297 char filename[128]; /* Name of file. */
3301 struct blame_commit *commit;
3302 unsigned int header:1;
3306 #define BLAME_CAT_FILE_CMD "git cat-file blob %s:%s"
3307 #define BLAME_INCREMENTAL_CMD "git blame --incremental %s %s"
3310 blame_open(struct view *view)
3312 char path[SIZEOF_STR];
3313 char ref[SIZEOF_STR] = "";
3315 if (sq_quote(path, 0, opt_file) >= sizeof(path))
3318 if (*opt_ref && sq_quote(ref, 0, opt_ref) >= sizeof(ref))
3322 if (!string_format(view->cmd, BLAME_CAT_FILE_CMD, ref, path))
3325 view->pipe = fopen(opt_file, "r");
3327 !string_format(view->cmd, BLAME_CAT_FILE_CMD, "HEAD", path))
3332 view->pipe = popen(view->cmd, "r");
3336 if (!string_format(view->cmd, BLAME_INCREMENTAL_CMD, ref, path))
3339 string_format(view->ref, "%s ...", opt_file);
3340 string_copy_rev(view->vid, opt_file);
3341 set_nonblocking_input(TRUE);
3346 for (i = 0; i < view->lines; i++)
3347 free(view->line[i].data);
3351 view->lines = view->line_alloc = view->line_size = view->lineno = 0;
3352 view->offset = view->lines = view->lineno = 0;
3354 view->start_time = time(NULL);
3359 static struct blame_commit *
3360 get_blame_commit(struct view *view, const char *id)
3364 for (i = 0; i < view->lines; i++) {
3365 struct blame *blame = view->line[i].data;
3370 if (!strncmp(blame->commit->id, id, SIZEOF_REV - 1))
3371 return blame->commit;
3375 struct blame_commit *commit = calloc(1, sizeof(*commit));
3378 string_ncopy(commit->id, id, SIZEOF_REV);
3384 parse_number(char **posref, size_t *number, size_t min, size_t max)
3386 char *pos = *posref;
3389 pos = strchr(pos + 1, ' ');
3390 if (!pos || !isdigit(pos[1]))
3392 *number = atoi(pos + 1);
3393 if (*number < min || *number > max)
3400 static struct blame_commit *
3401 parse_blame_commit(struct view *view, char *text, int *blamed)
3403 struct blame_commit *commit;
3404 struct blame *blame;
3405 char *pos = text + SIZEOF_REV - 1;
3409 if (strlen(text) <= SIZEOF_REV || *pos != ' ')
3412 if (!parse_number(&pos, &lineno, 1, view->lines) ||
3413 !parse_number(&pos, &group, 1, view->lines - lineno + 1))
3416 commit = get_blame_commit(view, text);
3422 struct line *line = &view->line[lineno + group - 1];
3425 blame->commit = commit;
3426 blame->header = !group;
3434 blame_read_file(struct view *view, char *line)
3439 if (view->lines > 0)
3440 pipe = popen(view->cmd, "r");
3443 report("Failed to load blame data");
3452 size_t linelen = strlen(line);
3453 struct blame *blame = malloc(sizeof(*blame) + linelen);
3458 blame->commit = NULL;
3459 strncpy(blame->text, line, linelen);
3460 blame->text[linelen] = 0;
3461 return add_line_data(view, blame, LINE_BLAME_COMMIT) != NULL;
3466 match_blame_header(const char *name, char **line)
3468 size_t namelen = strlen(name);
3469 bool matched = !strncmp(name, *line, namelen);
3478 blame_read(struct view *view, char *line)
3480 static struct blame_commit *commit = NULL;
3481 static int blamed = 0;
3482 static time_t author_time;
3485 return blame_read_file(view, line);
3491 string_format(view->ref, "%s", view->vid);
3492 if (view_is_displayed(view)) {
3493 update_view_title(view);
3494 redraw_view_from(view, 0);
3500 commit = parse_blame_commit(view, line, &blamed);
3501 string_format(view->ref, "%s %2d%%", view->vid,
3502 blamed * 100 / view->lines);
3504 } else if (match_blame_header("author ", &line)) {
3505 string_ncopy(commit->author, line, strlen(line));
3507 } else if (match_blame_header("author-time ", &line)) {
3508 author_time = (time_t) atol(line);
3510 } else if (match_blame_header("author-tz ", &line)) {
3513 tz = ('0' - line[1]) * 60 * 60 * 10;
3514 tz += ('0' - line[2]) * 60 * 60;
3515 tz += ('0' - line[3]) * 60;
3516 tz += ('0' - line[4]) * 60;
3522 gmtime_r(&author_time, &commit->time);
3524 } else if (match_blame_header("summary ", &line)) {
3525 string_ncopy(commit->title, line, strlen(line));
3527 } else if (match_blame_header("filename ", &line)) {
3528 string_ncopy(commit->filename, line, strlen(line));
3536 blame_draw(struct view *view, struct line *line, unsigned int lineno, bool selected)
3538 struct blame *blame = line->data;
3541 wmove(view->win, lineno, 0);
3544 wattrset(view->win, get_line_attr(LINE_CURSOR));
3545 wchgat(view->win, -1, 0, LINE_CURSOR, NULL);
3547 wattrset(view->win, A_NORMAL);
3554 wattrset(view->win, get_line_attr(LINE_MAIN_DATE));
3555 if (blame->commit) {
3556 char buf[DATE_COLS + 1];
3559 timelen = strftime(buf, sizeof(buf), DATE_FORMAT, &blame->commit->time);
3560 n = draw_text(view, buf, view->width - col, FALSE, selected);
3561 draw_text(view, " ", view->width - col - n, FALSE, selected);
3565 wmove(view->win, lineno, col);
3566 if (col >= view->width)
3571 int max = MIN(AUTHOR_COLS - 1, view->width - col);
3574 wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
3576 draw_text(view, blame->commit->author, max, TRUE, selected);
3578 if (col >= view->width)
3580 wmove(view->win, lineno, col);
3584 int max = MIN(ID_COLS - 1, view->width - col);
3587 wattrset(view->win, get_line_attr(LINE_BLAME_ID));
3589 draw_text(view, blame->commit->id, max, FALSE, -1);
3591 if (col >= view->width)
3593 wmove(view->win, lineno, col);
3597 unsigned long real_lineno = view->offset + lineno + 1;
3598 char number[10] = " ";
3599 int max = MIN(view->digits, STRING_SIZE(number));
3600 bool showtrimmed = FALSE;
3602 if (real_lineno == 1 ||
3603 (real_lineno % opt_num_interval) == 0) {
3604 char fmt[] = "%1ld";
3606 if (view->digits <= 9)
3607 fmt[1] = '0' + view->digits;
3609 if (!string_format(number, fmt, real_lineno))
3614 if (max > view->width - col)
3615 max = view->width - col;
3617 wattrset(view->win, get_line_attr(LINE_BLAME_LINENO));
3618 col += draw_text(view, number, max, showtrimmed, selected);
3619 if (col >= view->width)
3624 wattrset(view->win, A_NORMAL);
3626 if (col >= view->width)
3628 waddch(view->win, ACS_VLINE);
3630 if (col >= view->width)
3632 waddch(view->win, ' ');
3634 col += draw_text(view, blame->text, view->width - col, TRUE, selected);
3640 blame_request(struct view *view, enum request request, struct line *line)
3642 enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
3643 struct blame *blame = line->data;
3647 if (!blame->commit) {
3648 report("No commit loaded yet");
3652 if (!strcmp(blame->commit->id, NULL_ID)) {
3653 char path[SIZEOF_STR];
3655 if (sq_quote(path, 0, view->vid) >= sizeof(path))
3657 string_format(opt_cmd, "git diff-index --root --patch-with-stat -C -M --cached HEAD -- %s 2>/dev/null", path);
3660 open_view(view, REQ_VIEW_DIFF, flags);
3671 blame_grep(struct view *view, struct line *line)
3673 struct blame *blame = line->data;
3674 struct blame_commit *commit = blame->commit;
3677 #define MATCH(text) \
3678 (*text && regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
3681 char buf[DATE_COLS + 1];
3683 if (MATCH(commit->title) ||
3684 MATCH(commit->author) ||
3688 if (strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time) &&
3693 return MATCH(blame->text);
3699 blame_select(struct view *view, struct line *line)
3701 struct blame *blame = line->data;
3702 struct blame_commit *commit = blame->commit;
3707 if (!strcmp(commit->id, NULL_ID))
3708 string_ncopy(ref_commit, "HEAD", 4);
3710 string_copy_rev(ref_commit, commit->id);
3713 static struct view_ops blame_ops = {
3731 char rev[SIZEOF_REV];
3732 char name[SIZEOF_STR];
3736 char rev[SIZEOF_REV];
3737 char name[SIZEOF_STR];
3741 static char status_onbranch[SIZEOF_STR];
3742 static struct status stage_status;
3743 static enum line_type stage_line_type;
3745 /* Get fields from the diff line:
3746 * :100644 100644 06a5d6ae9eca55be2e0e585a152e6b1336f2b20e 0000000000000000000000000000000000000000 M
3749 status_get_diff(struct status *file, char *buf, size_t bufsize)
3751 char *old_mode = buf + 1;
3752 char *new_mode = buf + 8;
3753 char *old_rev = buf + 15;
3754 char *new_rev = buf + 56;
3755 char *status = buf + 97;
3758 old_mode[-1] != ':' ||
3759 new_mode[-1] != ' ' ||
3760 old_rev[-1] != ' ' ||
3761 new_rev[-1] != ' ' ||
3765 file->status = *status;
3767 string_copy_rev(file->old.rev, old_rev);
3768 string_copy_rev(file->new.rev, new_rev);
3770 file->old.mode = strtoul(old_mode, NULL, 8);
3771 file->new.mode = strtoul(new_mode, NULL, 8);
3773 file->old.name[0] = file->new.name[0] = 0;
3779 status_run(struct view *view, const char cmd[], char status, enum line_type type)
3781 struct status *file = NULL;
3782 struct status *unmerged = NULL;
3783 char buf[SIZEOF_STR * 4];
3787 pipe = popen(cmd, "r");
3791 add_line_data(view, NULL, type);
3793 while (!feof(pipe) && !ferror(pipe)) {
3797 readsize = fread(buf + bufsize, 1, sizeof(buf) - bufsize, pipe);
3800 bufsize += readsize;
3802 /* Process while we have NUL chars. */
3803 while ((sep = memchr(buf, 0, bufsize))) {
3804 size_t sepsize = sep - buf + 1;
3807 if (!realloc_lines(view, view->line_size + 1))
3810 file = calloc(1, sizeof(*file));
3814 add_line_data(view, file, type);
3817 /* Parse diff info part. */
3819 file->status = status;
3821 string_copy(file->old.rev, NULL_ID);
3823 } else if (!file->status) {
3824 if (!status_get_diff(file, buf, sepsize))
3828 memmove(buf, sep + 1, bufsize);
3830 sep = memchr(buf, 0, bufsize);
3833 sepsize = sep - buf + 1;
3835 /* Collapse all 'M'odified entries that
3836 * follow a associated 'U'nmerged entry.
3838 if (file->status == 'U') {
3841 } else if (unmerged) {
3842 int collapse = !strcmp(buf, unmerged->new.name);
3853 /* Grab the old name for rename/copy. */
3854 if (!*file->old.name &&
3855 (file->status == 'R' || file->status == 'C')) {
3856 sepsize = sep - buf + 1;
3857 string_ncopy(file->old.name, buf, sepsize);
3859 memmove(buf, sep + 1, bufsize);
3861 sep = memchr(buf, 0, bufsize);
3864 sepsize = sep - buf + 1;
3867 /* git-ls-files just delivers a NUL separated
3868 * list of file names similar to the second half
3869 * of the git-diff-* output. */
3870 string_ncopy(file->new.name, buf, sepsize);
3871 if (!*file->old.name)
3872 string_copy(file->old.name, file->new.name);
3874 memmove(buf, sep + 1, bufsize);
3885 if (!view->line[view->lines - 1].data)
3886 add_line_data(view, NULL, LINE_STAT_NONE);
3892 /* Don't show unmerged entries in the staged section. */
3893 #define STATUS_DIFF_INDEX_CMD "git diff-index -z --diff-filter=ACDMRTXB --cached -M HEAD"
3894 #define STATUS_DIFF_FILES_CMD "git diff-files -z"
3895 #define STATUS_LIST_OTHER_CMD \
3896 "git ls-files -z --others --exclude-per-directory=.gitignore"
3897 #define STATUS_LIST_NO_HEAD_CMD \
3898 "git ls-files -z --cached --exclude-per-directory=.gitignore"
3900 #define STATUS_DIFF_INDEX_SHOW_CMD \
3901 "git diff-index --root --patch-with-stat -C -M --cached HEAD -- %s %s 2>/dev/null"
3903 #define STATUS_DIFF_FILES_SHOW_CMD \
3904 "git diff-files --root --patch-with-stat -C -M -- %s %s 2>/dev/null"
3906 #define STATUS_DIFF_NO_HEAD_SHOW_CMD \
3907 "git diff --no-color --patch-with-stat /dev/null %s 2>/dev/null"
3909 /* First parse staged info using git-diff-index(1), then parse unstaged
3910 * info using git-diff-files(1), and finally untracked files using
3911 * git-ls-files(1). */
3913 status_open(struct view *view)
3915 struct stat statbuf;
3916 char exclude[SIZEOF_STR];
3917 char indexcmd[SIZEOF_STR] = STATUS_DIFF_INDEX_CMD;
3918 char othercmd[SIZEOF_STR] = STATUS_LIST_OTHER_CMD;
3919 unsigned long prev_lineno = view->lineno;
3920 char indexstatus = 0;
3923 for (i = 0; i < view->lines; i++)
3924 free(view->line[i].data);
3926 view->lines = view->line_alloc = view->line_size = view->lineno = 0;
3929 if (!realloc_lines(view, view->line_size + 7))
3932 add_line_data(view, NULL, LINE_STAT_HEAD);
3934 string_copy(status_onbranch, "Initial commit");
3935 else if (!*opt_head)
3936 string_copy(status_onbranch, "Not currently on any branch");
3937 else if (!string_format(status_onbranch, "On branch %s", opt_head))
3941 string_copy(indexcmd, STATUS_LIST_NO_HEAD_CMD);
3945 if (!string_format(exclude, "%s/info/exclude", opt_git_dir))
3948 if (stat(exclude, &statbuf) >= 0) {
3949 size_t cmdsize = strlen(othercmd);
3951 if (!string_format_from(othercmd, &cmdsize, " %s", "--exclude-from=") ||
3952 sq_quote(othercmd, cmdsize, exclude) >= sizeof(othercmd))
3955 cmdsize = strlen(indexcmd);
3957 (!string_format_from(indexcmd, &cmdsize, " %s", "--exclude-from=") ||
3958 sq_quote(indexcmd, cmdsize, exclude) >= sizeof(indexcmd)))
3962 system("git update-index -q --refresh");
3964 if (!status_run(view, indexcmd, indexstatus, LINE_STAT_STAGED) ||
3965 !status_run(view, STATUS_DIFF_FILES_CMD, 0, LINE_STAT_UNSTAGED) ||
3966 !status_run(view, othercmd, '?', LINE_STAT_UNTRACKED))
3969 /* If all went well restore the previous line number to stay in
3970 * the context or select a line with something that can be
3972 if (prev_lineno >= view->lines)
3973 prev_lineno = view->lines - 1;
3974 while (prev_lineno < view->lines && !view->line[prev_lineno].data)
3976 while (prev_lineno > 0 && !view->line[prev_lineno].data)
3979 /* If the above fails, always skip the "On branch" line. */
3980 if (prev_lineno < view->lines)
3981 view->lineno = prev_lineno;
3985 if (view->lineno < view->offset)
3986 view->offset = view->lineno;
3987 else if (view->offset + view->height <= view->lineno)
3988 view->offset = view->lineno - view->height + 1;
3994 status_draw(struct view *view, struct line *line, unsigned int lineno, bool selected)
3996 struct status *status = line->data;
3998 wmove(view->win, lineno, 0);
4001 wattrset(view->win, get_line_attr(LINE_CURSOR));
4002 wchgat(view->win, -1, 0, LINE_CURSOR, NULL);
4004 } else if (line->type == LINE_STAT_HEAD) {
4005 wattrset(view->win, get_line_attr(LINE_STAT_HEAD));
4006 wchgat(view->win, -1, 0, LINE_STAT_HEAD, NULL);
4008 } else if (!status && line->type != LINE_STAT_NONE) {
4009 wattrset(view->win, get_line_attr(LINE_STAT_SECTION));
4010 wchgat(view->win, -1, 0, LINE_STAT_SECTION, NULL);
4013 wattrset(view->win, get_line_attr(line->type));
4019 switch (line->type) {
4020 case LINE_STAT_STAGED:
4021 text = "Changes to be committed:";
4024 case LINE_STAT_UNSTAGED:
4025 text = "Changed but not updated:";
4028 case LINE_STAT_UNTRACKED:
4029 text = "Untracked files:";
4032 case LINE_STAT_NONE:
4033 text = " (no files)";
4036 case LINE_STAT_HEAD:
4037 text = status_onbranch;
4044 draw_text(view, text, view->width, TRUE, selected);
4048 waddch(view->win, status->status);
4050 wattrset(view->win, A_NORMAL);
4051 wmove(view->win, lineno, 4);
4052 if (view->width < 5)
4055 draw_text(view, status->new.name, view->width - 5, TRUE, selected);
4060 status_enter(struct view *view, struct line *line)
4062 struct status *status = line->data;
4063 char oldpath[SIZEOF_STR] = "";
4064 char newpath[SIZEOF_STR] = "";
4068 if (line->type == LINE_STAT_NONE ||
4069 (!status && line[1].type == LINE_STAT_NONE)) {
4070 report("No file to diff");
4075 if (sq_quote(oldpath, 0, status->old.name) >= sizeof(oldpath))
4077 /* Diffs for unmerged entries are empty when pasing the
4078 * new path, so leave it empty. */
4079 if (status->status != 'U' &&
4080 sq_quote(newpath, 0, status->new.name) >= sizeof(newpath))
4085 line->type != LINE_STAT_UNTRACKED &&
4086 !string_format_from(opt_cmd, &cmdsize, "cd %s;", opt_cdup))
4089 switch (line->type) {
4090 case LINE_STAT_STAGED:
4092 if (!string_format_from(opt_cmd, &cmdsize,
4093 STATUS_DIFF_NO_HEAD_SHOW_CMD,
4097 if (!string_format_from(opt_cmd, &cmdsize,
4098 STATUS_DIFF_INDEX_SHOW_CMD,
4104 info = "Staged changes to %s";
4106 info = "Staged changes";
4109 case LINE_STAT_UNSTAGED:
4110 if (!string_format_from(opt_cmd, &cmdsize,
4111 STATUS_DIFF_FILES_SHOW_CMD, oldpath, newpath))
4114 info = "Unstaged changes to %s";
4116 info = "Unstaged changes";
4119 case LINE_STAT_UNTRACKED:
4124 report("No file to show");
4128 opt_pipe = fopen(status->new.name, "r");
4129 info = "Untracked file %s";
4132 case LINE_STAT_HEAD:
4136 die("line type %d not handled in switch", line->type);
4139 open_view(view, REQ_VIEW_STAGE, OPEN_RELOAD | OPEN_SPLIT);
4140 if (view_is_displayed(VIEW(REQ_VIEW_STAGE))) {
4142 stage_status = *status;
4144 memset(&stage_status, 0, sizeof(stage_status));
4147 stage_line_type = line->type;
4148 string_format(VIEW(REQ_VIEW_STAGE)->ref, info, stage_status.new.name);
4156 status_update_prepare(enum line_type type)
4158 char cmd[SIZEOF_STR];
4162 type != LINE_STAT_UNTRACKED &&
4163 !string_format_from(cmd, &cmdsize, "cd %s;", opt_cdup))
4167 case LINE_STAT_STAGED:
4168 string_add(cmd, cmdsize, "git update-index -z --index-info");
4171 case LINE_STAT_UNSTAGED:
4172 case LINE_STAT_UNTRACKED:
4173 string_add(cmd, cmdsize, "git update-index -z --add --remove --stdin");
4177 die("line type %d not handled in switch", type);
4180 return popen(cmd, "w");
4184 status_update_write(FILE *pipe, struct status *status, enum line_type type)
4186 char buf[SIZEOF_STR];
4191 case LINE_STAT_STAGED:
4192 if (!string_format_from(buf, &bufsize, "%06o %s\t%s%c",
4195 status->old.name, 0))
4199 case LINE_STAT_UNSTAGED:
4200 case LINE_STAT_UNTRACKED:
4201 if (!string_format_from(buf, &bufsize, "%s%c", status->new.name, 0))
4206 die("line type %d not handled in switch", type);
4209 while (!ferror(pipe) && written < bufsize) {
4210 written += fwrite(buf + written, 1, bufsize - written, pipe);
4213 return written == bufsize;
4217 status_update_file(struct status *status, enum line_type type)
4219 FILE *pipe = status_update_prepare(type);
4225 result = status_update_write(pipe, status, type);
4231 status_update_files(struct view *view, struct line *line)
4233 FILE *pipe = status_update_prepare(line->type);
4235 struct line *pos = view->line + view->lines;
4242 for (pos = line; pos < view->line + view->lines && pos->data; pos++)
4245 for (file = 0, done = 0; result && file < files; line++, file++) {
4246 int almost_done = file * 100 / files;
4248 if (almost_done > done) {
4250 string_format(view->ref, "updating file %u of %u (%d%% done)",
4252 update_view_title(view);
4254 result = status_update_write(pipe, line->data, line->type);
4262 status_update(struct view *view)
4264 struct line *line = &view->line[view->lineno];
4266 assert(view->lines);
4269 /* This should work even for the "On branch" line. */
4270 if (line < view->line + view->lines && !line[1].data) {
4271 report("Nothing to update");
4275 if (!status_update_files(view, line + 1))
4276 report("Failed to update file status");
4278 } else if (!status_update_file(line->data, line->type)) {
4279 report("Failed to update file status");
4286 status_request(struct view *view, enum request request, struct line *line)
4288 struct status *status = line->data;
4291 case REQ_STATUS_UPDATE:
4292 if (!status_update(view))
4296 case REQ_STATUS_MERGE:
4297 if (!status || status->status != 'U') {
4298 report("Merging only possible for files with unmerged status ('U').");
4301 open_mergetool(status->new.name);
4308 open_editor(status->status != '?', status->new.name);
4311 case REQ_VIEW_BLAME:
4313 string_copy(opt_file, status->new.name);
4319 /* After returning the status view has been split to
4320 * show the stage view. No further reloading is
4322 status_enter(view, line);
4326 /* Simply reload the view. */
4333 open_view(view, REQ_VIEW_STATUS, OPEN_RELOAD);
4339 status_select(struct view *view, struct line *line)
4341 struct status *status = line->data;
4342 char file[SIZEOF_STR] = "all files";
4346 if (status && !string_format(file, "'%s'", status->new.name))
4349 if (!status && line[1].type == LINE_STAT_NONE)
4352 switch (line->type) {
4353 case LINE_STAT_STAGED:
4354 text = "Press %s to unstage %s for commit";
4357 case LINE_STAT_UNSTAGED:
4358 text = "Press %s to stage %s for commit";
4361 case LINE_STAT_UNTRACKED:
4362 text = "Press %s to stage %s for addition";
4365 case LINE_STAT_HEAD:
4366 case LINE_STAT_NONE:
4367 text = "Nothing to update";
4371 die("line type %d not handled in switch", line->type);
4374 if (status && status->status == 'U') {
4375 text = "Press %s to resolve conflict in %s";
4376 key = get_key(REQ_STATUS_MERGE);
4379 key = get_key(REQ_STATUS_UPDATE);
4382 string_format(view->ref, text, key, file);
4386 status_grep(struct view *view, struct line *line)
4388 struct status *status = line->data;
4389 enum { S_STATUS, S_NAME, S_END } state;
4396 for (state = S_STATUS; state < S_END; state++) {
4400 case S_NAME: text = status->new.name; break;
4402 buf[0] = status->status;
4410 if (regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
4417 static struct view_ops status_ops = {
4429 stage_diff_line(FILE *pipe, struct line *line)
4431 char *buf = line->data;
4432 size_t bufsize = strlen(buf);
4435 while (!ferror(pipe) && written < bufsize) {
4436 written += fwrite(buf + written, 1, bufsize - written, pipe);
4441 return written == bufsize;
4444 static struct line *
4445 stage_diff_hdr(struct view *view, struct line *line)
4447 int diff_hdr_dir = line->type == LINE_DIFF_CHUNK ? -1 : 1;
4448 struct line *diff_hdr;
4450 if (line->type == LINE_DIFF_CHUNK)
4451 diff_hdr = line - 1;
4453 diff_hdr = view->line + 1;
4455 while (diff_hdr > view->line && diff_hdr < view->line + view->lines) {
4456 if (diff_hdr->type == LINE_DIFF_HEADER)
4459 diff_hdr += diff_hdr_dir;
4466 stage_update_chunk(struct view *view, struct line *line)
4468 char cmd[SIZEOF_STR];
4470 struct line *diff_hdr, *diff_chunk, *diff_end;
4473 diff_hdr = stage_diff_hdr(view, line);
4478 !string_format_from(cmd, &cmdsize, "cd %s;", opt_cdup))
4481 if (!string_format_from(cmd, &cmdsize,
4482 "git apply --whitespace=nowarn --cached %s - && "
4483 "git update-index -q --unmerged --refresh 2>/dev/null",
4484 stage_line_type == LINE_STAT_STAGED ? "-R" : ""))
4487 pipe = popen(cmd, "w");
4491 diff_end = view->line + view->lines;
4492 if (line->type != LINE_DIFF_CHUNK) {
4493 diff_chunk = diff_hdr;
4496 for (diff_chunk = line + 1; diff_chunk < diff_end; diff_chunk++)
4497 if (diff_chunk->type == LINE_DIFF_CHUNK ||
4498 diff_chunk->type == LINE_DIFF_HEADER)
4499 diff_end = diff_chunk;
4503 while (diff_hdr->type != LINE_DIFF_CHUNK) {
4504 switch (diff_hdr->type) {
4505 case LINE_DIFF_HEADER:
4506 case LINE_DIFF_INDEX:
4516 if (!stage_diff_line(pipe, diff_hdr++)) {
4523 while (diff_chunk < diff_end && stage_diff_line(pipe, diff_chunk))
4528 if (diff_chunk != diff_end)
4535 stage_update(struct view *view, struct line *line)
4537 if (!opt_no_head && stage_line_type != LINE_STAT_UNTRACKED &&
4538 (line->type == LINE_DIFF_CHUNK || !stage_status.status)) {
4539 if (!stage_update_chunk(view, line)) {
4540 report("Failed to apply chunk");
4544 } else if (!status_update_file(&stage_status, stage_line_type)) {
4545 report("Failed to update file");
4549 open_view(view, REQ_VIEW_STATUS, OPEN_RELOAD);
4551 view = VIEW(REQ_VIEW_STATUS);
4552 if (view_is_displayed(view))
4553 status_enter(view, &view->line[view->lineno]);
4557 stage_request(struct view *view, enum request request, struct line *line)
4560 case REQ_STATUS_UPDATE:
4561 stage_update(view, line);
4565 if (!stage_status.new.name[0])
4568 open_editor(stage_status.status != '?', stage_status.new.name);
4571 case REQ_VIEW_BLAME:
4572 if (stage_status.new.name[0]) {
4573 string_copy(opt_file, stage_status.new.name);
4579 pager_request(view, request, line);
4589 static struct view_ops stage_ops = {
4605 char id[SIZEOF_REV]; /* SHA1 ID. */
4606 char title[128]; /* First line of the commit message. */
4607 char author[75]; /* Author of the commit. */
4608 struct tm time; /* Date from the author ident. */
4609 struct ref **refs; /* Repository references. */
4610 chtype graph[SIZEOF_REVGRAPH]; /* Ancestry chain graphics. */
4611 size_t graph_size; /* The width of the graph array. */
4612 bool has_parents; /* Rewritten --parents seen. */
4615 /* Size of rev graph with no "padding" columns */
4616 #define SIZEOF_REVITEMS (SIZEOF_REVGRAPH - (SIZEOF_REVGRAPH / 2))
4619 struct rev_graph *prev, *next, *parents;
4620 char rev[SIZEOF_REVITEMS][SIZEOF_REV];
4622 struct commit *commit;
4624 unsigned int boundary:1;
4627 /* Parents of the commit being visualized. */
4628 static struct rev_graph graph_parents[4];
4630 /* The current stack of revisions on the graph. */
4631 static struct rev_graph graph_stacks[4] = {
4632 { &graph_stacks[3], &graph_stacks[1], &graph_parents[0] },
4633 { &graph_stacks[0], &graph_stacks[2], &graph_parents[1] },
4634 { &graph_stacks[1], &graph_stacks[3], &graph_parents[2] },
4635 { &graph_stacks[2], &graph_stacks[0], &graph_parents[3] },
4639 graph_parent_is_merge(struct rev_graph *graph)
4641 return graph->parents->size > 1;
4645 append_to_rev_graph(struct rev_graph *graph, chtype symbol)
4647 struct commit *commit = graph->commit;
4649 if (commit->graph_size < ARRAY_SIZE(commit->graph) - 1)
4650 commit->graph[commit->graph_size++] = symbol;
4654 done_rev_graph(struct rev_graph *graph)
4656 if (graph_parent_is_merge(graph) &&
4657 graph->pos < graph->size - 1 &&
4658 graph->next->size == graph->size + graph->parents->size - 1) {
4659 size_t i = graph->pos + graph->parents->size - 1;
4661 graph->commit->graph_size = i * 2;
4662 while (i < graph->next->size - 1) {
4663 append_to_rev_graph(graph, ' ');
4664 append_to_rev_graph(graph, '\\');
4669 graph->size = graph->pos = 0;
4670 graph->commit = NULL;
4671 memset(graph->parents, 0, sizeof(*graph->parents));
4675 push_rev_graph(struct rev_graph *graph, char *parent)
4679 /* "Collapse" duplicate parents lines.
4681 * FIXME: This needs to also update update the drawn graph but
4682 * for now it just serves as a method for pruning graph lines. */
4683 for (i = 0; i < graph->size; i++)
4684 if (!strncmp(graph->rev[i], parent, SIZEOF_REV))
4687 if (graph->size < SIZEOF_REVITEMS) {
4688 string_copy_rev(graph->rev[graph->size++], parent);
4693 get_rev_graph_symbol(struct rev_graph *graph)
4697 if (graph->boundary)
4698 symbol = REVGRAPH_BOUND;
4699 else if (graph->parents->size == 0)
4700 symbol = REVGRAPH_INIT;
4701 else if (graph_parent_is_merge(graph))
4702 symbol = REVGRAPH_MERGE;
4703 else if (graph->pos >= graph->size)
4704 symbol = REVGRAPH_BRANCH;
4706 symbol = REVGRAPH_COMMIT;
4712 draw_rev_graph(struct rev_graph *graph)
4715 chtype separator, line;
4717 enum { DEFAULT, RSHARP, RDIAG, LDIAG };
4718 static struct rev_filler fillers[] = {
4719 { ' ', REVGRAPH_LINE },
4724 chtype symbol = get_rev_graph_symbol(graph);
4725 struct rev_filler *filler;
4728 filler = &fillers[DEFAULT];
4730 for (i = 0; i < graph->pos; i++) {
4731 append_to_rev_graph(graph, filler->line);
4732 if (graph_parent_is_merge(graph->prev) &&
4733 graph->prev->pos == i)
4734 filler = &fillers[RSHARP];
4736 append_to_rev_graph(graph, filler->separator);
4739 /* Place the symbol for this revision. */
4740 append_to_rev_graph(graph, symbol);
4742 if (graph->prev->size > graph->size)
4743 filler = &fillers[RDIAG];
4745 filler = &fillers[DEFAULT];
4749 for (; i < graph->size; i++) {
4750 append_to_rev_graph(graph, filler->separator);
4751 append_to_rev_graph(graph, filler->line);
4752 if (graph_parent_is_merge(graph->prev) &&
4753 i < graph->prev->pos + graph->parents->size)
4754 filler = &fillers[RSHARP];
4755 if (graph->prev->size > graph->size)
4756 filler = &fillers[LDIAG];
4759 if (graph->prev->size > graph->size) {
4760 append_to_rev_graph(graph, filler->separator);
4761 if (filler->line != ' ')
4762 append_to_rev_graph(graph, filler->line);
4766 /* Prepare the next rev graph */
4768 prepare_rev_graph(struct rev_graph *graph)
4772 /* First, traverse all lines of revisions up to the active one. */
4773 for (graph->pos = 0; graph->pos < graph->size; graph->pos++) {
4774 if (!strcmp(graph->rev[graph->pos], graph->commit->id))
4777 push_rev_graph(graph->next, graph->rev[graph->pos]);
4780 /* Interleave the new revision parent(s). */
4781 for (i = 0; !graph->boundary && i < graph->parents->size; i++)
4782 push_rev_graph(graph->next, graph->parents->rev[i]);
4784 /* Lastly, put any remaining revisions. */
4785 for (i = graph->pos + 1; i < graph->size; i++)
4786 push_rev_graph(graph->next, graph->rev[i]);
4790 update_rev_graph(struct rev_graph *graph)
4792 /* If this is the finalizing update ... */
4794 prepare_rev_graph(graph);
4796 /* Graph visualization needs a one rev look-ahead,
4797 * so the first update doesn't visualize anything. */
4798 if (!graph->prev->commit)
4801 draw_rev_graph(graph->prev);
4802 done_rev_graph(graph->prev->prev);
4811 main_draw(struct view *view, struct line *line, unsigned int lineno, bool selected)
4813 char buf[DATE_COLS + 1];
4814 struct commit *commit = line->data;
4815 enum line_type type;
4820 if (!*commit->author)
4823 space = view->width;
4824 wmove(view->win, lineno, col);
4828 wattrset(view->win, get_line_attr(type));
4829 wchgat(view->win, -1, 0, type, NULL);
4831 type = LINE_MAIN_COMMIT;
4832 wattrset(view->win, get_line_attr(LINE_MAIN_DATE));
4838 timelen = strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time);
4839 n = draw_text(view, buf, view->width - col, FALSE, selected);
4840 draw_text(view, " ", view->width - col - n, FALSE, selected);
4843 wmove(view->win, lineno, col);
4844 if (col >= view->width)
4847 if (type != LINE_CURSOR)
4848 wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
4853 max_len = view->width - col;
4854 if (max_len > AUTHOR_COLS - 1)
4855 max_len = AUTHOR_COLS - 1;
4856 draw_text(view, commit->author, max_len, TRUE, selected);
4858 if (col >= view->width)
4862 if (opt_rev_graph && commit->graph_size) {
4863 size_t graph_size = view->width - col;
4866 if (type != LINE_CURSOR)
4867 wattrset(view->win, get_line_attr(LINE_MAIN_REVGRAPH));
4868 wmove(view->win, lineno, col);
4869 if (graph_size > commit->graph_size)
4870 graph_size = commit->graph_size;
4871 /* Using waddch() instead of waddnstr() ensures that
4872 * they'll be rendered correctly for the cursor line. */
4873 for (i = 0; i < graph_size; i++)
4874 waddch(view->win, commit->graph[i]);
4876 col += commit->graph_size + 1;
4877 if (col >= view->width)
4879 waddch(view->win, ' ');
4881 if (type != LINE_CURSOR)
4882 wattrset(view->win, A_NORMAL);
4884 wmove(view->win, lineno, col);
4886 if (opt_show_refs && commit->refs) {
4890 if (type == LINE_CURSOR)
4892 else if (commit->refs[i]->head)
4893 wattrset(view->win, get_line_attr(LINE_MAIN_HEAD));
4894 else if (commit->refs[i]->ltag)
4895 wattrset(view->win, get_line_attr(LINE_MAIN_LOCAL_TAG));
4896 else if (commit->refs[i]->tag)
4897 wattrset(view->win, get_line_attr(LINE_MAIN_TAG));
4898 else if (commit->refs[i]->tracked)
4899 wattrset(view->win, get_line_attr(LINE_MAIN_TRACKED));
4900 else if (commit->refs[i]->remote)
4901 wattrset(view->win, get_line_attr(LINE_MAIN_REMOTE));
4903 wattrset(view->win, get_line_attr(LINE_MAIN_REF));
4905 col += draw_text(view, "[", view->width - col, TRUE, selected);
4906 col += draw_text(view, commit->refs[i]->name, view->width - col,
4908 col += draw_text(view, "]", view->width - col, TRUE, selected);
4909 if (type != LINE_CURSOR)
4910 wattrset(view->win, A_NORMAL);
4911 col += draw_text(view, " ", view->width - col, TRUE, selected);
4912 if (col >= view->width)
4914 } while (commit->refs[i++]->next);
4917 if (type != LINE_CURSOR)
4918 wattrset(view->win, get_line_attr(type));
4920 draw_text(view, commit->title, view->width - col, TRUE, selected);
4924 /* Reads git log --pretty=raw output and parses it into the commit struct. */
4926 main_read(struct view *view, char *line)
4928 static struct rev_graph *graph = graph_stacks;
4929 enum line_type type;
4930 struct commit *commit;
4933 update_rev_graph(graph);
4937 type = get_line_type(line);
4938 if (type == LINE_COMMIT) {
4939 commit = calloc(1, sizeof(struct commit));
4943 line += STRING_SIZE("commit ");
4945 graph->boundary = 1;
4949 string_copy_rev(commit->id, line);
4950 commit->refs = get_refs(commit->id);
4951 graph->commit = commit;
4952 add_line_data(view, commit, LINE_MAIN_COMMIT);
4954 while ((line = strchr(line, ' '))) {
4956 push_rev_graph(graph->parents, line);
4957 commit->has_parents = TRUE;
4964 commit = view->line[view->lines - 1].data;
4968 if (commit->has_parents)
4970 push_rev_graph(graph->parents, line + STRING_SIZE("parent "));
4975 /* Parse author lines where the name may be empty:
4976 * author <email@address.tld> 1138474660 +0100
4978 char *ident = line + STRING_SIZE("author ");
4979 char *nameend = strchr(ident, '<');
4980 char *emailend = strchr(ident, '>');
4982 if (!nameend || !emailend)
4985 update_rev_graph(graph);
4986 graph = graph->next;
4988 *nameend = *emailend = 0;
4989 ident = chomp_string(ident);
4991 ident = chomp_string(nameend + 1);
4996 string_ncopy(commit->author, ident, strlen(ident));
4998 /* Parse epoch and timezone */
4999 if (emailend[1] == ' ') {
5000 char *secs = emailend + 2;
5001 char *zone = strchr(secs, ' ');
5002 time_t time = (time_t) atol(secs);
5004 if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
5008 tz = ('0' - zone[1]) * 60 * 60 * 10;
5009 tz += ('0' - zone[2]) * 60 * 60;
5010 tz += ('0' - zone[3]) * 60;
5011 tz += ('0' - zone[4]) * 60;
5019 gmtime_r(&time, &commit->time);
5024 /* Fill in the commit title if it has not already been set. */
5025 if (commit->title[0])
5028 /* Require titles to start with a non-space character at the
5029 * offset used by git log. */
5030 if (strncmp(line, " ", 4))
5033 /* Well, if the title starts with a whitespace character,
5034 * try to be forgiving. Otherwise we end up with no title. */
5035 while (isspace(*line))
5039 /* FIXME: More graceful handling of titles; append "..." to
5040 * shortened titles, etc. */
5042 string_ncopy(commit->title, line, strlen(line));
5049 main_request(struct view *view, enum request request, struct line *line)
5051 enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
5053 if (request == REQ_ENTER)
5054 open_view(view, REQ_VIEW_DIFF, flags);
5062 main_grep(struct view *view, struct line *line)
5064 struct commit *commit = line->data;
5065 enum { S_TITLE, S_AUTHOR, S_DATE, S_END } state;
5066 char buf[DATE_COLS + 1];
5069 for (state = S_TITLE; state < S_END; state++) {
5073 case S_TITLE: text = commit->title; break;
5074 case S_AUTHOR: text = commit->author; break;
5076 if (!strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time))
5085 if (regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
5093 main_select(struct view *view, struct line *line)
5095 struct commit *commit = line->data;
5097 string_copy_rev(view->ref, commit->id);
5098 string_copy_rev(ref_commit, view->ref);
5101 static struct view_ops main_ops = {
5113 * Unicode / UTF-8 handling
5115 * NOTE: Much of the following code for dealing with unicode is derived from
5116 * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
5117 * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
5120 /* I've (over)annotated a lot of code snippets because I am not entirely
5121 * confident that the approach taken by this small UTF-8 interface is correct.
5125 unicode_width(unsigned long c)
5128 (c <= 0x115f /* Hangul Jamo */
5131 || (c >= 0x2e80 && c <= 0xa4cf && c != 0x303f)
5133 || (c >= 0xac00 && c <= 0xd7a3) /* Hangul Syllables */
5134 || (c >= 0xf900 && c <= 0xfaff) /* CJK Compatibility Ideographs */
5135 || (c >= 0xfe30 && c <= 0xfe6f) /* CJK Compatibility Forms */
5136 || (c >= 0xff00 && c <= 0xff60) /* Fullwidth Forms */
5137 || (c >= 0xffe0 && c <= 0xffe6)
5138 || (c >= 0x20000 && c <= 0x2fffd)
5139 || (c >= 0x30000 && c <= 0x3fffd)))
5143 return opt_tab_size;
5148 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
5149 * Illegal bytes are set one. */
5150 static const unsigned char utf8_bytes[256] = {
5151 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,
5152 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,
5153 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,
5154 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,
5155 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,
5156 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,
5157 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,
5158 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,
5161 /* Decode UTF-8 multi-byte representation into a unicode character. */
5162 static inline unsigned long
5163 utf8_to_unicode(const char *string, size_t length)
5165 unsigned long unicode;
5169 unicode = string[0];
5172 unicode = (string[0] & 0x1f) << 6;
5173 unicode += (string[1] & 0x3f);
5176 unicode = (string[0] & 0x0f) << 12;
5177 unicode += ((string[1] & 0x3f) << 6);
5178 unicode += (string[2] & 0x3f);
5181 unicode = (string[0] & 0x0f) << 18;
5182 unicode += ((string[1] & 0x3f) << 12);
5183 unicode += ((string[2] & 0x3f) << 6);
5184 unicode += (string[3] & 0x3f);
5187 unicode = (string[0] & 0x0f) << 24;
5188 unicode += ((string[1] & 0x3f) << 18);
5189 unicode += ((string[2] & 0x3f) << 12);
5190 unicode += ((string[3] & 0x3f) << 6);
5191 unicode += (string[4] & 0x3f);
5194 unicode = (string[0] & 0x01) << 30;
5195 unicode += ((string[1] & 0x3f) << 24);
5196 unicode += ((string[2] & 0x3f) << 18);
5197 unicode += ((string[3] & 0x3f) << 12);
5198 unicode += ((string[4] & 0x3f) << 6);
5199 unicode += (string[5] & 0x3f);
5202 die("Invalid unicode length");
5205 /* Invalid characters could return the special 0xfffd value but NUL
5206 * should be just as good. */
5207 return unicode > 0xffff ? 0 : unicode;
5210 /* Calculates how much of string can be shown within the given maximum width
5211 * and sets trimmed parameter to non-zero value if all of string could not be
5212 * shown. If the reserve flag is TRUE, it will reserve at least one
5213 * trailing character, which can be useful when drawing a delimiter.
5215 * Returns the number of bytes to output from string to satisfy max_width. */
5217 utf8_length(const char *string, size_t max_width, int *trimmed, bool reserve)
5219 const char *start = string;
5220 const char *end = strchr(string, '\0');
5221 unsigned char last_bytes = 0;
5226 while (string < end) {
5227 int c = *(unsigned char *) string;
5228 unsigned char bytes = utf8_bytes[c];
5230 unsigned long unicode;
5232 if (string + bytes > end)
5235 /* Change representation to figure out whether
5236 * it is a single- or double-width character. */
5238 unicode = utf8_to_unicode(string, bytes);
5239 /* FIXME: Graceful handling of invalid unicode character. */
5243 ucwidth = unicode_width(unicode);
5245 if (width > max_width) {
5247 if (reserve && width - ucwidth == max_width) {
5248 string -= last_bytes;
5257 return string - start;
5265 /* Whether or not the curses interface has been initialized. */
5266 static bool cursed = FALSE;
5268 /* The status window is used for polling keystrokes. */
5269 static WINDOW *status_win;
5271 static bool status_empty = TRUE;
5273 /* Update status and title window. */
5275 report(const char *msg, ...)
5277 struct view *view = display[current_view];
5283 char buf[SIZEOF_STR];
5286 va_start(args, msg);
5287 if (vsnprintf(buf, sizeof(buf), msg, args) >= sizeof(buf)) {
5288 buf[sizeof(buf) - 1] = 0;
5289 buf[sizeof(buf) - 2] = '.';
5290 buf[sizeof(buf) - 3] = '.';
5291 buf[sizeof(buf) - 4] = '.';
5297 if (!status_empty || *msg) {
5300 va_start(args, msg);
5302 wmove(status_win, 0, 0);
5304 vwprintw(status_win, msg, args);
5305 status_empty = FALSE;
5307 status_empty = TRUE;
5309 wclrtoeol(status_win);
5310 wrefresh(status_win);
5315 update_view_title(view);
5316 update_display_cursor(view);
5319 /* Controls when nodelay should be in effect when polling user input. */
5321 set_nonblocking_input(bool loading)
5323 static unsigned int loading_views;
5325 if ((loading == FALSE && loading_views-- == 1) ||
5326 (loading == TRUE && loading_views++ == 0))
5327 nodelay(status_win, loading);
5335 /* Initialize the curses library */
5336 if (isatty(STDIN_FILENO)) {
5337 cursed = !!initscr();
5339 /* Leave stdin and stdout alone when acting as a pager. */
5340 FILE *io = fopen("/dev/tty", "r+");
5343 die("Failed to open /dev/tty");
5344 cursed = !!newterm(NULL, io, io);
5348 die("Failed to initialize curses");
5350 nonl(); /* Tell curses not to do NL->CR/NL on output */
5351 cbreak(); /* Take input chars one at a time, no wait for \n */
5352 noecho(); /* Don't echo input */
5353 leaveok(stdscr, TRUE);
5358 getmaxyx(stdscr, y, x);
5359 status_win = newwin(1, 0, y - 1, 0);
5361 die("Failed to create status window");
5363 /* Enable keyboard mapping */
5364 keypad(status_win, TRUE);
5365 wbkgdset(status_win, get_line_attr(LINE_STATUS));
5369 read_prompt(const char *prompt)
5371 enum { READING, STOP, CANCEL } status = READING;
5372 static char buf[sizeof(opt_cmd) - STRING_SIZE("git \0")];
5375 while (status == READING) {
5381 foreach_view (view, i)
5386 mvwprintw(status_win, 0, 0, "%s%.*s", prompt, pos, buf);
5387 wclrtoeol(status_win);
5389 /* Refresh, accept single keystroke of input */
5390 key = wgetch(status_win);
5395 status = pos ? STOP : CANCEL;
5413 if (pos >= sizeof(buf)) {
5414 report("Input string too long");
5419 buf[pos++] = (char) key;
5423 /* Clear the status window */
5424 status_empty = FALSE;
5427 if (status == CANCEL)
5436 * Repository references
5439 static struct ref *refs = NULL;
5440 static size_t refs_alloc = 0;
5441 static size_t refs_size = 0;
5443 /* Id <-> ref store */
5444 static struct ref ***id_refs = NULL;
5445 static size_t id_refs_alloc = 0;
5446 static size_t id_refs_size = 0;
5448 static struct ref **
5451 struct ref ***tmp_id_refs;
5452 struct ref **ref_list = NULL;
5453 size_t ref_list_alloc = 0;
5454 size_t ref_list_size = 0;
5457 for (i = 0; i < id_refs_size; i++)
5458 if (!strcmp(id, id_refs[i][0]->id))
5461 tmp_id_refs = realloc_items(id_refs, &id_refs_alloc, id_refs_size + 1,
5466 id_refs = tmp_id_refs;
5468 for (i = 0; i < refs_size; i++) {
5471 if (strcmp(id, refs[i].id))
5474 tmp = realloc_items(ref_list, &ref_list_alloc,
5475 ref_list_size + 1, sizeof(*ref_list));
5483 if (ref_list_size > 0)
5484 ref_list[ref_list_size - 1]->next = 1;
5485 ref_list[ref_list_size] = &refs[i];
5487 /* XXX: The properties of the commit chains ensures that we can
5488 * safely modify the shared ref. The repo references will
5489 * always be similar for the same id. */
5490 ref_list[ref_list_size]->next = 0;
5495 id_refs[id_refs_size++] = ref_list;
5501 read_ref(char *id, size_t idlen, char *name, size_t namelen)
5506 bool remote = FALSE;
5507 bool tracked = FALSE;
5508 bool check_replace = FALSE;
5511 if (!strncmp(name, "refs/tags/", STRING_SIZE("refs/tags/"))) {
5512 if (!strcmp(name + namelen - 3, "^{}")) {
5515 if (refs_size > 0 && refs[refs_size - 1].ltag == TRUE)
5516 check_replace = TRUE;
5522 namelen -= STRING_SIZE("refs/tags/");
5523 name += STRING_SIZE("refs/tags/");
5525 } else if (!strncmp(name, "refs/remotes/", STRING_SIZE("refs/remotes/"))) {
5527 namelen -= STRING_SIZE("refs/remotes/");
5528 name += STRING_SIZE("refs/remotes/");
5529 tracked = !strcmp(opt_remote, name);
5531 } else if (!strncmp(name, "refs/heads/", STRING_SIZE("refs/heads/"))) {
5532 namelen -= STRING_SIZE("refs/heads/");
5533 name += STRING_SIZE("refs/heads/");
5534 head = !strncmp(opt_head, name, namelen);
5536 } else if (!strcmp(name, "HEAD")) {
5537 opt_no_head = FALSE;
5541 if (check_replace && !strcmp(name, refs[refs_size - 1].name)) {
5542 /* it's an annotated tag, replace the previous sha1 with the
5543 * resolved commit id; relies on the fact git-ls-remote lists
5544 * the commit id of an annotated tag right beofre the commit id
5546 refs[refs_size - 1].ltag = ltag;
5547 string_copy_rev(refs[refs_size - 1].id, id);
5551 refs = realloc_items(refs, &refs_alloc, refs_size + 1, sizeof(*refs));
5555 ref = &refs[refs_size++];
5556 ref->name = malloc(namelen + 1);
5560 strncpy(ref->name, name, namelen);
5561 ref->name[namelen] = 0;
5565 ref->remote = remote;
5566 ref->tracked = tracked;
5567 string_copy_rev(ref->id, id);
5575 const char *cmd_env = getenv("TIG_LS_REMOTE");
5576 const char *cmd = cmd_env && *cmd_env ? cmd_env : TIG_LS_REMOTE;
5578 return read_properties(popen(cmd, "r"), "\t", read_ref);
5582 read_repo_config_option(char *name, size_t namelen, char *value, size_t valuelen)
5584 if (!strcmp(name, "i18n.commitencoding"))
5585 string_ncopy(opt_encoding, value, valuelen);
5587 if (!strcmp(name, "core.editor"))
5588 string_ncopy(opt_editor, value, valuelen);
5590 /* branch.<head>.remote */
5592 !strncmp(name, "branch.", 7) &&
5593 !strncmp(name + 7, opt_head, strlen(opt_head)) &&
5594 !strcmp(name + 7 + strlen(opt_head), ".remote"))
5595 string_ncopy(opt_remote, value, valuelen);
5597 if (*opt_head && *opt_remote &&
5598 !strncmp(name, "branch.", 7) &&
5599 !strncmp(name + 7, opt_head, strlen(opt_head)) &&
5600 !strcmp(name + 7 + strlen(opt_head), ".merge")) {
5601 size_t from = strlen(opt_remote);
5603 if (!strncmp(value, "refs/heads/", STRING_SIZE("refs/heads/"))) {
5604 value += STRING_SIZE("refs/heads/");
5605 valuelen -= STRING_SIZE("refs/heads/");
5608 if (!string_format_from(opt_remote, &from, "/%s", value))
5616 load_repo_config(void)
5618 return read_properties(popen(GIT_CONFIG " --list", "r"),
5619 "=", read_repo_config_option);
5623 read_repo_info(char *name, size_t namelen, char *value, size_t valuelen)
5625 if (!opt_git_dir[0]) {
5626 string_ncopy(opt_git_dir, name, namelen);
5628 } else if (opt_is_inside_work_tree == -1) {
5629 /* This can be 3 different values depending on the
5630 * version of git being used. If git-rev-parse does not
5631 * understand --is-inside-work-tree it will simply echo
5632 * the option else either "true" or "false" is printed.
5633 * Default to true for the unknown case. */
5634 opt_is_inside_work_tree = strcmp(name, "false") ? TRUE : FALSE;
5636 } else if (opt_cdup[0] == ' ') {
5637 string_ncopy(opt_cdup, name, namelen);
5639 if (!strncmp(name, "refs/heads/", STRING_SIZE("refs/heads/"))) {
5640 namelen -= STRING_SIZE("refs/heads/");
5641 name += STRING_SIZE("refs/heads/");
5642 string_ncopy(opt_head, name, namelen);
5650 load_repo_info(void)
5653 FILE *pipe = popen("git rev-parse --git-dir --is-inside-work-tree "
5654 " --show-cdup --symbolic-full-name HEAD 2>/dev/null", "r");
5656 /* XXX: The line outputted by "--show-cdup" can be empty so
5657 * initialize it to something invalid to make it possible to
5658 * detect whether it has been set or not. */
5661 result = read_properties(pipe, "=", read_repo_info);
5662 if (opt_cdup[0] == ' ')
5669 read_properties(FILE *pipe, const char *separators,
5670 int (*read_property)(char *, size_t, char *, size_t))
5672 char buffer[BUFSIZ];
5679 while (state == OK && (name = fgets(buffer, sizeof(buffer), pipe))) {
5684 name = chomp_string(name);
5685 namelen = strcspn(name, separators);
5687 if (name[namelen]) {
5689 value = chomp_string(name + namelen + 1);
5690 valuelen = strlen(value);
5697 state = read_property(name, namelen, value, valuelen);
5700 if (state != ERR && ferror(pipe))
5713 static void __NORETURN
5716 /* XXX: Restore tty modes and let the OS cleanup the rest! */
5722 static void __NORETURN
5723 die(const char *err, ...)
5729 va_start(args, err);
5730 fputs("tig: ", stderr);
5731 vfprintf(stderr, err, args);
5732 fputs("\n", stderr);
5739 warn(const char *msg, ...)
5743 va_start(args, msg);
5744 fputs("tig warning: ", stderr);
5745 vfprintf(stderr, msg, args);
5746 fputs("\n", stderr);
5751 main(int argc, char *argv[])
5754 enum request request;
5757 signal(SIGINT, quit);
5759 if (setlocale(LC_ALL, "")) {
5760 char *codeset = nl_langinfo(CODESET);
5762 string_ncopy(opt_codeset, codeset, strlen(codeset));
5765 if (load_repo_info() == ERR)
5766 die("Failed to load repo info.");
5768 if (load_options() == ERR)
5769 die("Failed to load user config.");
5771 /* Load the repo config file so options can be overwritten from
5772 * the command line. */
5773 if (load_repo_config() == ERR)
5774 die("Failed to load repo config.");
5776 if (!parse_options(argc, argv))
5779 /* Require a git repository unless when running in pager mode. */
5780 if (!opt_git_dir[0] && opt_request != REQ_VIEW_PAGER)
5781 die("Not a git repository");
5783 if (*opt_encoding && strcasecmp(opt_encoding, "UTF-8"))
5786 if (*opt_codeset && strcmp(opt_codeset, opt_encoding)) {
5787 opt_iconv = iconv_open(opt_codeset, opt_encoding);
5788 if (opt_iconv == ICONV_NONE)
5789 die("Failed to initialize character set conversion");
5792 if (load_refs() == ERR)
5793 die("Failed to load refs.");
5795 for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
5796 view->cmd_env = getenv(view->cmd_env);
5798 request = opt_request;
5802 while (view_driver(display[current_view], request)) {
5806 foreach_view (view, i)
5809 /* Refresh, accept single keystroke of input */
5810 key = wgetch(status_win);
5812 /* wgetch() with nodelay() enabled returns ERR when there's no
5819 request = get_keybinding(display[current_view]->keymap, key);
5821 /* Some low-level request handling. This keeps access to
5822 * status_win restricted. */
5826 char *cmd = read_prompt(":");
5828 if (cmd && string_format(opt_cmd, "git %s", cmd)) {
5829 if (strncmp(cmd, "show", 4) && isspace(cmd[4])) {
5830 opt_request = REQ_VIEW_DIFF;
5832 opt_request = REQ_VIEW_PAGER;
5841 case REQ_SEARCH_BACK:
5843 const char *prompt = request == REQ_SEARCH
5845 char *search = read_prompt(prompt);
5848 string_ncopy(opt_search, search, strlen(search));
5853 case REQ_SCREEN_RESIZE:
5857 getmaxyx(stdscr, height, width);
5859 /* Resize the status view and let the view driver take
5860 * care of resizing the displayed views. */
5861 wresize(status_win, 1, width);
5862 mvwin(status_win, height - 1, 0);
5863 wrefresh(status_win);