1 /* Copyright (c) 2006-2008 Jonas Fonseca <fonseca@diku.dk>
2 *
3 * This program is free software; you can redistribute it and/or
4 * modify it under the terms of the GNU General Public License as
5 * published by the Free Software Foundation; either version 2 of
6 * the License, or (at your option) any later version.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 */
14 #ifdef HAVE_CONFIG_H
15 #include "config.h"
16 #endif
18 #ifndef TIG_VERSION
19 #define TIG_VERSION "unknown-version"
20 #endif
22 #ifndef DEBUG
23 #define NDEBUG
24 #endif
26 #include <assert.h>
27 #include <errno.h>
28 #include <ctype.h>
29 #include <signal.h>
30 #include <stdarg.h>
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #include <sys/types.h>
35 #include <sys/stat.h>
36 #include <unistd.h>
37 #include <time.h>
39 #include <regex.h>
41 #include <locale.h>
42 #include <langinfo.h>
43 #include <iconv.h>
45 /* ncurses(3): Must be defined to have extended wide-character functions. */
46 #define _XOPEN_SOURCE_EXTENDED
48 #include <curses.h>
50 #if __GNUC__ >= 3
51 #define __NORETURN __attribute__((__noreturn__))
52 #else
53 #define __NORETURN
54 #endif
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 */
73 /* Revision graph */
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)
88 #ifndef ICONV_CONST
89 #define ICONV_CONST /* nothing */
90 #endif
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
97 #define ID_COLS 8
99 /* The default interval between line numbers. */
100 #define NUMBER_INTERVAL 5
102 #define TABSIZE 8
104 #define SCALE_SPLIT_VIEW(height) ((height) * 2 / 3)
106 #define NULL_ID "0000000000000000000000000000000000000000"
108 #ifndef GIT_CONFIG
109 #define GIT_CONFIG "git config"
110 #endif
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 \
125 "git ls-tree %s %s"
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. */
138 #define KEY_TAB '\t'
139 #define KEY_RETURN '\r'
140 #define KEY_ESC 27
143 struct ref {
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? */
152 };
154 static struct ref **get_refs(char *id);
156 struct int_map {
157 const char *name;
158 int namelen;
159 int value;
160 };
162 static int
163 set_from_int_map(struct int_map *map, size_t map_size,
164 int *value, const char *name, int namelen)
165 {
167 int i;
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;
173 return OK;
174 }
176 return ERR;
177 }
180 /*
181 * String helpers
182 */
184 static inline void
185 string_ncopy_do(char *dst, size_t dstlen, const char *src, size_t srclen)
186 {
187 if (srclen > dstlen - 1)
188 srclen = dstlen - 1;
190 strncpy(dst, src, srclen);
191 dst[srclen] = 0;
192 }
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))
208 static char *
209 chomp_string(char *name)
210 {
211 int namelen;
213 while (isspace(*name))
214 name++;
216 namelen = strlen(name) - 1;
217 while (namelen > 0 && isspace(name[namelen]))
218 name[namelen--] = 0;
220 return name;
221 }
223 static bool
224 string_nformat(char *buf, size_t bufsize, size_t *bufpos, const char *fmt, ...)
225 {
226 va_list args;
227 size_t pos = bufpos ? *bufpos : 0;
229 va_start(args, fmt);
230 pos += vsnprintf(buf + pos, bufsize - pos, fmt, args);
231 va_end(args);
233 if (bufpos)
234 *bufpos = pos;
236 return pos >= bufsize ? FALSE : TRUE;
237 }
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)
245 static int
246 string_enum_compare(const char *str1, const char *str2, int len)
247 {
248 size_t i;
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]))
255 continue;
257 if (string_enum_sep(str1[i]) &&
258 string_enum_sep(str2[i]))
259 continue;
261 return str1[i] - str2[i];
262 }
264 return 0;
265 }
267 /* Shell quoting
268 *
269 * NOTE: The following is a slightly modified copy of the git project's shell
270 * quoting routines found in the quote.c file.
271 *
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
275 *
276 * E.g.
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'
282 */
284 static size_t
285 sq_quote(char buf[SIZEOF_STR], size_t bufsize, const char *src)
286 {
287 char c;
289 #define BUFPUT(x) do { if (bufsize < SIZEOF_STR) buf[bufsize++] = (x); } while (0)
291 BUFPUT('\'');
292 while ((c = *src++)) {
293 if (c == '\'' || c == '!') {
294 BUFPUT('\'');
295 BUFPUT('\\');
296 BUFPUT(c);
297 BUFPUT('\'');
298 } else {
299 BUFPUT(c);
300 }
301 }
302 BUFPUT('\'');
304 if (bufsize < SIZEOF_STR)
305 buf[bufsize] = 0;
307 return bufsize;
308 }
311 /*
312 * User requests
313 */
315 #define REQ_INFO \
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"), \
328 \
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_(MAXIMIZE, "Maximize the current view"), \
336 REQ_(VIEW_CLOSE, "Close the current view"), \
337 REQ_(QUIT, "Close all views and quit"), \
338 \
339 REQ_GROUP("Cursor navigation") \
340 REQ_(MOVE_UP, "Move cursor one line up"), \
341 REQ_(MOVE_DOWN, "Move cursor one line down"), \
342 REQ_(MOVE_PAGE_DOWN, "Move cursor one page down"), \
343 REQ_(MOVE_PAGE_UP, "Move cursor one page up"), \
344 REQ_(MOVE_FIRST_LINE, "Move cursor to first line"), \
345 REQ_(MOVE_LAST_LINE, "Move cursor to last line"), \
346 \
347 REQ_GROUP("Scrolling") \
348 REQ_(SCROLL_LINE_UP, "Scroll one line up"), \
349 REQ_(SCROLL_LINE_DOWN, "Scroll one line down"), \
350 REQ_(SCROLL_PAGE_UP, "Scroll one page up"), \
351 REQ_(SCROLL_PAGE_DOWN, "Scroll one page down"), \
352 \
353 REQ_GROUP("Searching") \
354 REQ_(SEARCH, "Search the view"), \
355 REQ_(SEARCH_BACK, "Search backwards in the view"), \
356 REQ_(FIND_NEXT, "Find next search match"), \
357 REQ_(FIND_PREV, "Find previous search match"), \
358 \
359 REQ_GROUP("Misc") \
360 REQ_(PROMPT, "Bring up the prompt"), \
361 REQ_(SCREEN_REDRAW, "Redraw the screen"), \
362 REQ_(SCREEN_RESIZE, "Resize the screen"), \
363 REQ_(SHOW_VERSION, "Show version information"), \
364 REQ_(STOP_LOADING, "Stop all loading views"), \
365 REQ_(TOGGLE_LINENO, "Toggle line numbers"), \
366 REQ_(TOGGLE_DATE, "Toggle date display"), \
367 REQ_(TOGGLE_AUTHOR, "Toggle author display"), \
368 REQ_(TOGGLE_REV_GRAPH, "Toggle revision graph visualization"), \
369 REQ_(TOGGLE_REFS, "Toggle reference display (tags/branches)"), \
370 REQ_(STATUS_UPDATE, "Update file status"), \
371 REQ_(STATUS_MERGE, "Merge file using external tool"), \
372 REQ_(TREE_PARENT, "Switch to parent directory in tree view"), \
373 REQ_(EDIT, "Open in editor"), \
374 REQ_(NONE, "Do nothing")
377 /* User action requests. */
378 enum request {
379 #define REQ_GROUP(help)
380 #define REQ_(req, help) REQ_##req
382 /* Offset all requests to avoid conflicts with ncurses getch values. */
383 REQ_OFFSET = KEY_MAX + 1,
384 REQ_INFO
386 #undef REQ_GROUP
387 #undef REQ_
388 };
390 struct request_info {
391 enum request request;
392 char *name;
393 int namelen;
394 char *help;
395 };
397 static struct request_info req_info[] = {
398 #define REQ_GROUP(help) { 0, NULL, 0, (help) },
399 #define REQ_(req, help) { REQ_##req, (#req), STRING_SIZE(#req), (help) }
400 REQ_INFO
401 #undef REQ_GROUP
402 #undef REQ_
403 };
405 static enum request
406 get_request(const char *name)
407 {
408 int namelen = strlen(name);
409 int i;
411 for (i = 0; i < ARRAY_SIZE(req_info); i++)
412 if (req_info[i].namelen == namelen &&
413 !string_enum_compare(req_info[i].name, name, namelen))
414 return req_info[i].request;
416 return REQ_NONE;
417 }
420 /*
421 * Options
422 */
424 static const char usage[] =
425 "tig " TIG_VERSION " (" __DATE__ ")\n"
426 "\n"
427 "Usage: tig [options] [revs] [--] [paths]\n"
428 " or: tig show [options] [revs] [--] [paths]\n"
429 " or: tig blame [rev] path\n"
430 " or: tig status\n"
431 " or: tig < [git command output]\n"
432 "\n"
433 "Options:\n"
434 " -v, --version Show version and exit\n"
435 " -h, --help Show help message and exit";
437 /* Option and state variables. */
438 static bool opt_date = TRUE;
439 static bool opt_author = TRUE;
440 static bool opt_line_number = FALSE;
441 static bool opt_rev_graph = FALSE;
442 static bool opt_show_refs = TRUE;
443 static int opt_num_interval = NUMBER_INTERVAL;
444 static int opt_tab_size = TABSIZE;
445 static enum request opt_request = REQ_VIEW_MAIN;
446 static char opt_cmd[SIZEOF_STR] = "";
447 static char opt_path[SIZEOF_STR] = "";
448 static char opt_file[SIZEOF_STR] = "";
449 static char opt_ref[SIZEOF_REF] = "";
450 static char opt_head[SIZEOF_REF] = "";
451 static char opt_remote[SIZEOF_REF] = "";
452 static bool opt_no_head = TRUE;
453 static FILE *opt_pipe = NULL;
454 static char opt_encoding[20] = "UTF-8";
455 static bool opt_utf8 = TRUE;
456 static char opt_codeset[20] = "UTF-8";
457 static iconv_t opt_iconv = ICONV_NONE;
458 static char opt_search[SIZEOF_STR] = "";
459 static char opt_cdup[SIZEOF_STR] = "";
460 static char opt_git_dir[SIZEOF_STR] = "";
461 static signed char opt_is_inside_work_tree = -1; /* set to TRUE or FALSE */
462 static char opt_editor[SIZEOF_STR] = "";
464 static bool
465 parse_options(int argc, char *argv[])
466 {
467 size_t buf_size;
468 char *subcommand;
469 bool seen_dashdash = FALSE;
470 int i;
472 if (!isatty(STDIN_FILENO)) {
473 opt_request = REQ_VIEW_PAGER;
474 opt_pipe = stdin;
475 return TRUE;
476 }
478 if (argc <= 1)
479 return TRUE;
481 subcommand = argv[1];
482 if (!strcmp(subcommand, "status") || !strcmp(subcommand, "-S")) {
483 opt_request = REQ_VIEW_STATUS;
484 if (!strcmp(subcommand, "-S"))
485 warn("`-S' has been deprecated; use `tig status' instead");
486 if (argc > 2)
487 warn("ignoring arguments after `%s'", subcommand);
488 return TRUE;
490 } else if (!strcmp(subcommand, "blame")) {
491 opt_request = REQ_VIEW_BLAME;
492 if (argc <= 2 || argc > 4)
493 die("invalid number of options to blame\n\n%s", usage);
495 i = 2;
496 if (argc == 4) {
497 string_ncopy(opt_ref, argv[i], strlen(argv[i]));
498 i++;
499 }
501 string_ncopy(opt_file, argv[i], strlen(argv[i]));
502 return TRUE;
504 } else if (!strcmp(subcommand, "show")) {
505 opt_request = REQ_VIEW_DIFF;
507 } else if (!strcmp(subcommand, "log") || !strcmp(subcommand, "diff")) {
508 opt_request = subcommand[0] == 'l'
509 ? REQ_VIEW_LOG : REQ_VIEW_DIFF;
510 warn("`tig %s' has been deprecated", subcommand);
512 } else {
513 subcommand = NULL;
514 }
516 if (!subcommand)
517 /* XXX: This is vulnerable to the user overriding
518 * options required for the main view parser. */
519 string_copy(opt_cmd, "git log --no-color --pretty=raw --boundary --parents");
520 else
521 string_format(opt_cmd, "git %s", subcommand);
523 buf_size = strlen(opt_cmd);
525 for (i = 1 + !!subcommand; i < argc; i++) {
526 char *opt = argv[i];
528 if (seen_dashdash || !strcmp(opt, "--")) {
529 seen_dashdash = TRUE;
531 } else if (!strcmp(opt, "-v") || !strcmp(opt, "--version")) {
532 printf("tig version %s\n", TIG_VERSION);
533 return FALSE;
535 } else if (!strcmp(opt, "-h") || !strcmp(opt, "--help")) {
536 printf("%s\n", usage);
537 return FALSE;
538 }
540 opt_cmd[buf_size++] = ' ';
541 buf_size = sq_quote(opt_cmd, buf_size, opt);
542 if (buf_size >= sizeof(opt_cmd))
543 die("command too long");
544 }
546 opt_cmd[buf_size] = 0;
548 return TRUE;
549 }
552 /*
553 * Line-oriented content detection.
554 */
556 #define LINE_INFO \
557 LINE(DIFF_HEADER, "diff --git ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
558 LINE(DIFF_CHUNK, "@@", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
559 LINE(DIFF_ADD, "+", COLOR_GREEN, COLOR_DEFAULT, 0), \
560 LINE(DIFF_DEL, "-", COLOR_RED, COLOR_DEFAULT, 0), \
561 LINE(DIFF_INDEX, "index ", COLOR_BLUE, COLOR_DEFAULT, 0), \
562 LINE(DIFF_OLDMODE, "old file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
563 LINE(DIFF_NEWMODE, "new file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
564 LINE(DIFF_COPY_FROM, "copy from", COLOR_YELLOW, COLOR_DEFAULT, 0), \
565 LINE(DIFF_COPY_TO, "copy to", COLOR_YELLOW, COLOR_DEFAULT, 0), \
566 LINE(DIFF_RENAME_FROM, "rename from", COLOR_YELLOW, COLOR_DEFAULT, 0), \
567 LINE(DIFF_RENAME_TO, "rename to", COLOR_YELLOW, COLOR_DEFAULT, 0), \
568 LINE(DIFF_SIMILARITY, "similarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
569 LINE(DIFF_DISSIMILARITY,"dissimilarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
570 LINE(DIFF_TREE, "diff-tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
571 LINE(PP_AUTHOR, "Author: ", COLOR_CYAN, COLOR_DEFAULT, 0), \
572 LINE(PP_COMMIT, "Commit: ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
573 LINE(PP_MERGE, "Merge: ", COLOR_BLUE, COLOR_DEFAULT, 0), \
574 LINE(PP_DATE, "Date: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
575 LINE(PP_ADATE, "AuthorDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
576 LINE(PP_CDATE, "CommitDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
577 LINE(PP_REFS, "Refs: ", COLOR_RED, COLOR_DEFAULT, 0), \
578 LINE(COMMIT, "commit ", COLOR_GREEN, COLOR_DEFAULT, 0), \
579 LINE(PARENT, "parent ", COLOR_BLUE, COLOR_DEFAULT, 0), \
580 LINE(TREE, "tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
581 LINE(AUTHOR, "author ", COLOR_CYAN, COLOR_DEFAULT, 0), \
582 LINE(COMMITTER, "committer ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
583 LINE(SIGNOFF, " Signed-off-by", COLOR_YELLOW, COLOR_DEFAULT, 0), \
584 LINE(ACKED, " Acked-by", COLOR_YELLOW, COLOR_DEFAULT, 0), \
585 LINE(DEFAULT, "", COLOR_DEFAULT, COLOR_DEFAULT, A_NORMAL), \
586 LINE(CURSOR, "", COLOR_WHITE, COLOR_GREEN, A_BOLD), \
587 LINE(STATUS, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
588 LINE(DELIMITER, "", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
589 LINE(DATE, "", COLOR_BLUE, COLOR_DEFAULT, 0), \
590 LINE(LINE_NUMBER, "", COLOR_CYAN, COLOR_DEFAULT, 0), \
591 LINE(TITLE_BLUR, "", COLOR_WHITE, COLOR_BLUE, 0), \
592 LINE(TITLE_FOCUS, "", COLOR_WHITE, COLOR_BLUE, A_BOLD), \
593 LINE(MAIN_AUTHOR, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
594 LINE(MAIN_COMMIT, "", COLOR_DEFAULT, COLOR_DEFAULT, 0), \
595 LINE(MAIN_TAG, "", COLOR_MAGENTA, COLOR_DEFAULT, A_BOLD), \
596 LINE(MAIN_LOCAL_TAG,"", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
597 LINE(MAIN_REMOTE, "", COLOR_YELLOW, COLOR_DEFAULT, 0), \
598 LINE(MAIN_TRACKED, "", COLOR_YELLOW, COLOR_DEFAULT, A_BOLD), \
599 LINE(MAIN_REF, "", COLOR_CYAN, COLOR_DEFAULT, 0), \
600 LINE(MAIN_HEAD, "", COLOR_CYAN, COLOR_DEFAULT, A_BOLD), \
601 LINE(MAIN_REVGRAPH,"", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
602 LINE(TREE_DIR, "", COLOR_DEFAULT, COLOR_DEFAULT, A_NORMAL), \
603 LINE(TREE_FILE, "", COLOR_DEFAULT, COLOR_DEFAULT, A_NORMAL), \
604 LINE(STAT_HEAD, "", COLOR_YELLOW, COLOR_DEFAULT, 0), \
605 LINE(STAT_SECTION, "", COLOR_CYAN, COLOR_DEFAULT, 0), \
606 LINE(STAT_NONE, "", COLOR_DEFAULT, COLOR_DEFAULT, 0), \
607 LINE(STAT_STAGED, "", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
608 LINE(STAT_UNSTAGED,"", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
609 LINE(STAT_UNTRACKED,"", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
610 LINE(BLAME_ID, "", COLOR_MAGENTA, COLOR_DEFAULT, 0)
612 enum line_type {
613 #define LINE(type, line, fg, bg, attr) \
614 LINE_##type
615 LINE_INFO
616 #undef LINE
617 };
619 struct line_info {
620 const char *name; /* Option name. */
621 int namelen; /* Size of option name. */
622 const char *line; /* The start of line to match. */
623 int linelen; /* Size of string to match. */
624 int fg, bg, attr; /* Color and text attributes for the lines. */
625 };
627 static struct line_info line_info[] = {
628 #define LINE(type, line, fg, bg, attr) \
629 { #type, STRING_SIZE(#type), (line), STRING_SIZE(line), (fg), (bg), (attr) }
630 LINE_INFO
631 #undef LINE
632 };
634 static enum line_type
635 get_line_type(char *line)
636 {
637 int linelen = strlen(line);
638 enum line_type type;
640 for (type = 0; type < ARRAY_SIZE(line_info); type++)
641 /* Case insensitive search matches Signed-off-by lines better. */
642 if (linelen >= line_info[type].linelen &&
643 !strncasecmp(line_info[type].line, line, line_info[type].linelen))
644 return type;
646 return LINE_DEFAULT;
647 }
649 static inline int
650 get_line_attr(enum line_type type)
651 {
652 assert(type < ARRAY_SIZE(line_info));
653 return COLOR_PAIR(type) | line_info[type].attr;
654 }
656 static struct line_info *
657 get_line_info(char *name)
658 {
659 size_t namelen = strlen(name);
660 enum line_type type;
662 for (type = 0; type < ARRAY_SIZE(line_info); type++)
663 if (namelen == line_info[type].namelen &&
664 !string_enum_compare(line_info[type].name, name, namelen))
665 return &line_info[type];
667 return NULL;
668 }
670 static void
671 init_colors(void)
672 {
673 int default_bg = line_info[LINE_DEFAULT].bg;
674 int default_fg = line_info[LINE_DEFAULT].fg;
675 enum line_type type;
677 start_color();
679 if (assume_default_colors(default_fg, default_bg) == ERR) {
680 default_bg = COLOR_BLACK;
681 default_fg = COLOR_WHITE;
682 }
684 for (type = 0; type < ARRAY_SIZE(line_info); type++) {
685 struct line_info *info = &line_info[type];
686 int bg = info->bg == COLOR_DEFAULT ? default_bg : info->bg;
687 int fg = info->fg == COLOR_DEFAULT ? default_fg : info->fg;
689 init_pair(type, fg, bg);
690 }
691 }
693 struct line {
694 enum line_type type;
696 /* State flags */
697 unsigned int selected:1;
698 unsigned int dirty:1;
700 void *data; /* User data */
701 };
704 /*
705 * Keys
706 */
708 struct keybinding {
709 int alias;
710 enum request request;
711 struct keybinding *next;
712 };
714 static struct keybinding default_keybindings[] = {
715 /* View switching */
716 { 'm', REQ_VIEW_MAIN },
717 { 'd', REQ_VIEW_DIFF },
718 { 'l', REQ_VIEW_LOG },
719 { 't', REQ_VIEW_TREE },
720 { 'f', REQ_VIEW_BLOB },
721 { 'B', REQ_VIEW_BLAME },
722 { 'p', REQ_VIEW_PAGER },
723 { 'h', REQ_VIEW_HELP },
724 { 'S', REQ_VIEW_STATUS },
725 { 'c', REQ_VIEW_STAGE },
727 /* View manipulation */
728 { 'q', REQ_VIEW_CLOSE },
729 { KEY_TAB, REQ_VIEW_NEXT },
730 { KEY_RETURN, REQ_ENTER },
731 { KEY_UP, REQ_PREVIOUS },
732 { KEY_DOWN, REQ_NEXT },
733 { 'R', REQ_REFRESH },
734 { KEY_F(5), REQ_REFRESH },
735 { 'O', REQ_MAXIMIZE },
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 },
748 /* Scrolling */
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 },
754 /* Searching */
755 { '/', REQ_SEARCH },
756 { '?', REQ_SEARCH_BACK },
757 { 'n', REQ_FIND_NEXT },
758 { 'N', REQ_FIND_PREV },
760 /* Misc */
761 { 'Q', REQ_QUIT },
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 },
770 { ':', REQ_PROMPT },
771 { 'u', REQ_STATUS_UPDATE },
772 { 'M', REQ_STATUS_MERGE },
773 { ',', REQ_TREE_PARENT },
774 { 'e', REQ_EDIT },
776 /* Using the ncurses SIGWINCH handler. */
777 { KEY_RESIZE, REQ_SCREEN_RESIZE },
778 };
780 #define KEYMAP_INFO \
781 KEYMAP_(GENERIC), \
782 KEYMAP_(MAIN), \
783 KEYMAP_(DIFF), \
784 KEYMAP_(LOG), \
785 KEYMAP_(TREE), \
786 KEYMAP_(BLOB), \
787 KEYMAP_(BLAME), \
788 KEYMAP_(PAGER), \
789 KEYMAP_(HELP), \
790 KEYMAP_(STATUS), \
791 KEYMAP_(STAGE)
793 enum keymap {
794 #define KEYMAP_(name) KEYMAP_##name
795 KEYMAP_INFO
796 #undef KEYMAP_
797 };
799 static struct int_map keymap_table[] = {
800 #define KEYMAP_(name) { #name, STRING_SIZE(#name), KEYMAP_##name }
801 KEYMAP_INFO
802 #undef KEYMAP_
803 };
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)];
810 static void
811 add_keybinding(enum keymap keymap, enum request request, int key)
812 {
813 struct keybinding *keybinding;
815 keybinding = calloc(1, sizeof(*keybinding));
816 if (!keybinding)
817 die("Failed to allocate keybinding");
819 keybinding->alias = key;
820 keybinding->request = request;
821 keybinding->next = keybindings[keymap];
822 keybindings[keymap] = keybinding;
823 }
825 /* Looks for a key binding first in the given map, then in the generic map, and
826 * lastly in the default keybindings. */
827 static enum request
828 get_keybinding(enum keymap keymap, int key)
829 {
830 struct keybinding *kbd;
831 int i;
833 for (kbd = keybindings[keymap]; kbd; kbd = kbd->next)
834 if (kbd->alias == key)
835 return kbd->request;
837 for (kbd = keybindings[KEYMAP_GENERIC]; kbd; kbd = kbd->next)
838 if (kbd->alias == key)
839 return kbd->request;
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;
846 }
849 struct key {
850 char *name;
851 int value;
852 };
854 static struct key key_table[] = {
855 { "Enter", KEY_RETURN },
856 { "Space", ' ' },
857 { "Backspace", KEY_BACKSPACE },
858 { "Tab", KEY_TAB },
859 { "Escape", KEY_ESC },
860 { "Left", KEY_LEFT },
861 { "Right", KEY_RIGHT },
862 { "Up", KEY_UP },
863 { "Down", KEY_DOWN },
864 { "Insert", KEY_IC },
865 { "Delete", KEY_DC },
866 { "Hash", '#' },
867 { "Home", KEY_HOME },
868 { "End", KEY_END },
869 { "PageUp", KEY_PPAGE },
870 { "PageDown", KEY_NPAGE },
871 { "F1", KEY_F(1) },
872 { "F2", KEY_F(2) },
873 { "F3", KEY_F(3) },
874 { "F4", KEY_F(4) },
875 { "F5", KEY_F(5) },
876 { "F6", KEY_F(6) },
877 { "F7", KEY_F(7) },
878 { "F8", KEY_F(8) },
879 { "F9", KEY_F(9) },
880 { "F10", KEY_F(10) },
881 { "F11", KEY_F(11) },
882 { "F12", KEY_F(12) },
883 };
885 static int
886 get_key_value(const char *name)
887 {
888 int i;
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))
895 return (int) *name;
897 return ERR;
898 }
900 static char *
901 get_key_name(int key_value)
902 {
903 static char key_char[] = "'X'";
904 char *seq = NULL;
905 int key;
907 for (key = 0; key < ARRAY_SIZE(key_table); key++)
908 if (key_table[key].value == key_value)
909 seq = key_table[key].name;
911 if (seq == NULL &&
912 key_value < 127 &&
913 isprint(key_value)) {
914 key_char[1] = (char) key_value;
915 seq = key_char;
916 }
918 return seq ? seq : "'?'";
919 }
921 static char *
922 get_key(enum request request)
923 {
924 static char buf[BUFSIZ];
925 size_t pos = 0;
926 char *sep = "";
927 int i;
929 buf[pos] = 0;
931 for (i = 0; i < ARRAY_SIZE(default_keybindings); i++) {
932 struct keybinding *keybinding = &default_keybindings[i];
934 if (keybinding->request != request)
935 continue;
937 if (!string_format_from(buf, &pos, "%s%s", sep,
938 get_key_name(keybinding->alias)))
939 return "Too many keybindings!";
940 sep = ", ";
941 }
943 return buf;
944 }
946 struct run_request {
947 enum keymap keymap;
948 int key;
949 char cmd[SIZEOF_STR];
950 };
952 static struct run_request *run_request;
953 static size_t run_requests;
955 static enum request
956 add_run_request(enum keymap keymap, int key, int argc, char **argv)
957 {
958 struct run_request *tmp;
959 struct run_request req = { keymap, key };
960 size_t bufpos;
962 for (bufpos = 0; argc > 0; argc--, argv++)
963 if (!string_format_from(req.cmd, &bufpos, "%s ", *argv))
964 return REQ_NONE;
966 req.cmd[bufpos - 1] = 0;
968 tmp = realloc(run_request, (run_requests + 1) * sizeof(*run_request));
969 if (!tmp)
970 return REQ_NONE;
972 run_request = tmp;
973 run_request[run_requests++] = req;
975 return REQ_NONE + run_requests;
976 }
978 static struct run_request *
979 get_run_request(enum request request)
980 {
981 if (request <= REQ_NONE)
982 return NULL;
983 return &run_request[request - REQ_NONE - 1];
984 }
986 static void
987 add_builtin_run_requests(void)
988 {
989 struct {
990 enum keymap keymap;
991 int key;
992 char *argv[1];
993 } reqs[] = {
994 { KEYMAP_MAIN, 'C', { "git cherry-pick %(commit)" } },
995 { KEYMAP_GENERIC, 'G', { "git gc" } },
996 };
997 int i;
999 for (i = 0; i < ARRAY_SIZE(reqs); i++) {
1000 enum request req;
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);
1005 }
1006 }
1008 /*
1009 * User config file handling.
1010 */
1012 static struct int_map color_map[] = {
1013 #define COLOR_MAP(name) { #name, STRING_SIZE(#name), COLOR_##name }
1014 COLOR_MAP(DEFAULT),
1015 COLOR_MAP(BLACK),
1016 COLOR_MAP(BLUE),
1017 COLOR_MAP(CYAN),
1018 COLOR_MAP(GREEN),
1019 COLOR_MAP(MAGENTA),
1020 COLOR_MAP(RED),
1021 COLOR_MAP(WHITE),
1022 COLOR_MAP(YELLOW),
1023 };
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 }
1030 ATTR_MAP(NORMAL),
1031 ATTR_MAP(BLINK),
1032 ATTR_MAP(BOLD),
1033 ATTR_MAP(DIM),
1034 ATTR_MAP(REVERSE),
1035 ATTR_MAP(STANDOUT),
1036 ATTR_MAP(UNDERLINE),
1037 };
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] */
1047 static int
1048 option_color_command(int argc, char *argv[])
1049 {
1050 struct line_info *info;
1052 if (argc != 3 && argc != 4) {
1053 config_msg = "Wrong number of arguments given to color command";
1054 return ERR;
1055 }
1057 info = get_line_info(argv[0]);
1058 if (!info) {
1059 if (!string_enum_compare(argv[0], "main-delim", strlen("main-delim"))) {
1060 info = get_line_info("delimiter");
1062 } else if (!string_enum_compare(argv[0], "main-date", strlen("main-date"))) {
1063 info = get_line_info("date");
1065 } else {
1066 config_msg = "Unknown color name";
1067 return ERR;
1068 }
1069 }
1071 if (set_color(&info->fg, argv[1]) == ERR ||
1072 set_color(&info->bg, argv[2]) == ERR) {
1073 config_msg = "Unknown color";
1074 return ERR;
1075 }
1077 if (argc == 4 && set_attribute(&info->attr, argv[3]) == ERR) {
1078 config_msg = "Unknown attribute";
1079 return ERR;
1080 }
1082 return OK;
1083 }
1085 static bool parse_bool(const char *s)
1086 {
1087 return (!strcmp(s, "1") || !strcmp(s, "true") ||
1088 !strcmp(s, "yes")) ? TRUE : FALSE;
1089 }
1091 /* Wants: name = value */
1092 static int
1093 option_set_command(int argc, char *argv[])
1094 {
1095 if (argc != 3) {
1096 config_msg = "Wrong number of arguments given to set command";
1097 return ERR;
1098 }
1100 if (strcmp(argv[1], "=")) {
1101 config_msg = "No value assigned";
1102 return ERR;
1103 }
1105 if (!strcmp(argv[0], "show-author")) {
1106 opt_author = parse_bool(argv[2]);
1107 return OK;
1108 }
1110 if (!strcmp(argv[0], "show-date")) {
1111 opt_date = parse_bool(argv[2]);
1112 return OK;
1113 }
1115 if (!strcmp(argv[0], "show-rev-graph")) {
1116 opt_rev_graph = parse_bool(argv[2]);
1117 return OK;
1118 }
1120 if (!strcmp(argv[0], "show-refs")) {
1121 opt_show_refs = parse_bool(argv[2]);
1122 return OK;
1123 }
1125 if (!strcmp(argv[0], "show-line-numbers")) {
1126 opt_line_number = parse_bool(argv[2]);
1127 return OK;
1128 }
1130 if (!strcmp(argv[0], "line-number-interval")) {
1131 opt_num_interval = atoi(argv[2]);
1132 return OK;
1133 }
1135 if (!strcmp(argv[0], "tab-size")) {
1136 opt_tab_size = atoi(argv[2]);
1137 return OK;
1138 }
1140 if (!strcmp(argv[0], "commit-encoding")) {
1141 char *arg = argv[2];
1142 int delimiter = *arg;
1143 int i;
1145 switch (delimiter) {
1146 case '"':
1147 case '\'':
1148 for (arg++, i = 0; arg[i]; i++)
1149 if (arg[i] == delimiter) {
1150 arg[i] = 0;
1151 break;
1152 }
1153 default:
1154 string_ncopy(opt_encoding, arg, strlen(arg));
1155 return OK;
1156 }
1157 }
1159 config_msg = "Unknown variable name";
1160 return ERR;
1161 }
1163 /* Wants: mode request key */
1164 static int
1165 option_bind_command(int argc, char *argv[])
1166 {
1167 enum request request;
1168 int keymap;
1169 int key;
1171 if (argc < 3) {
1172 config_msg = "Wrong number of arguments given to bind command";
1173 return ERR;
1174 }
1176 if (set_keymap(&keymap, argv[0]) == ERR) {
1177 config_msg = "Unknown key map";
1178 return ERR;
1179 }
1181 key = get_key_value(argv[1]);
1182 if (key == ERR) {
1183 config_msg = "Unknown key";
1184 return ERR;
1185 }
1187 request = get_request(argv[2]);
1188 if (request == REQ_NONE) {
1189 const char *obsolete[] = { "cherry-pick" };
1190 size_t namelen = strlen(argv[2]);
1191 int i;
1193 for (i = 0; i < ARRAY_SIZE(obsolete); i++) {
1194 if (namelen == strlen(obsolete[i]) &&
1195 !string_enum_compare(obsolete[i], argv[2], namelen)) {
1196 config_msg = "Obsolete request name";
1197 return ERR;
1198 }
1199 }
1200 }
1201 if (request == REQ_NONE && *argv[2]++ == '!')
1202 request = add_run_request(keymap, key, argc - 2, argv + 2);
1203 if (request == REQ_NONE) {
1204 config_msg = "Unknown request name";
1205 return ERR;
1206 }
1208 add_keybinding(keymap, request, key);
1210 return OK;
1211 }
1213 static int
1214 set_option(char *opt, char *value)
1215 {
1216 char *argv[16];
1217 int valuelen;
1218 int argc = 0;
1220 /* Tokenize */
1221 while (argc < ARRAY_SIZE(argv) && (valuelen = strcspn(value, " \t"))) {
1222 argv[argc++] = value;
1223 value += valuelen;
1225 /* Nothing more to tokenize or last available token. */
1226 if (!*value || argc >= ARRAY_SIZE(argv))
1227 break;
1229 *value++ = 0;
1230 while (isspace(*value))
1231 value++;
1232 }
1234 if (!strcmp(opt, "color"))
1235 return option_color_command(argc, argv);
1237 if (!strcmp(opt, "set"))
1238 return option_set_command(argc, argv);
1240 if (!strcmp(opt, "bind"))
1241 return option_bind_command(argc, argv);
1243 config_msg = "Unknown option command";
1244 return ERR;
1245 }
1247 static int
1248 read_option(char *opt, size_t optlen, char *value, size_t valuelen)
1249 {
1250 int status = OK;
1252 config_lineno++;
1253 config_msg = "Internal error";
1255 /* Check for comment markers, since read_properties() will
1256 * only ensure opt and value are split at first " \t". */
1257 optlen = strcspn(opt, "#");
1258 if (optlen == 0)
1259 return OK;
1261 if (opt[optlen] != 0) {
1262 config_msg = "No option value";
1263 status = ERR;
1265 } else {
1266 /* Look for comment endings in the value. */
1267 size_t len = strcspn(value, "#");
1269 if (len < valuelen) {
1270 valuelen = len;
1271 value[valuelen] = 0;
1272 }
1274 status = set_option(opt, value);
1275 }
1277 if (status == ERR) {
1278 fprintf(stderr, "Error on line %d, near '%.*s': %s\n",
1279 config_lineno, (int) optlen, opt, config_msg);
1280 config_errors = TRUE;
1281 }
1283 /* Always keep going if errors are encountered. */
1284 return OK;
1285 }
1287 static void
1288 load_option_file(const char *path)
1289 {
1290 FILE *file;
1292 /* It's ok that the file doesn't exist. */
1293 file = fopen(path, "r");
1294 if (!file)
1295 return;
1297 config_lineno = 0;
1298 config_errors = FALSE;
1300 if (read_properties(file, " \t", read_option) == ERR ||
1301 config_errors == TRUE)
1302 fprintf(stderr, "Errors while loading %s.\n", path);
1303 }
1305 static int
1306 load_options(void)
1307 {
1308 char *home = getenv("HOME");
1309 char *tigrc_user = getenv("TIGRC_USER");
1310 char *tigrc_system = getenv("TIGRC_SYSTEM");
1311 char buf[SIZEOF_STR];
1313 add_builtin_run_requests();
1315 if (!tigrc_system) {
1316 if (!string_format(buf, "%s/tigrc", SYSCONFDIR))
1317 return ERR;
1318 tigrc_system = buf;
1319 }
1320 load_option_file(tigrc_system);
1322 if (!tigrc_user) {
1323 if (!home || !string_format(buf, "%s/.tigrc", home))
1324 return ERR;
1325 tigrc_user = buf;
1326 }
1327 load_option_file(tigrc_user);
1329 return OK;
1330 }
1333 /*
1334 * The viewer
1335 */
1337 struct view;
1338 struct view_ops;
1340 /* The display array of active views and the index of the current view. */
1341 static struct view *display[2];
1342 static unsigned int current_view;
1344 /* Reading from the prompt? */
1345 static bool input_mode = FALSE;
1347 #define foreach_displayed_view(view, i) \
1348 for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
1350 #define displayed_views() (display[1] != NULL ? 2 : 1)
1352 /* Current head and commit ID */
1353 static char ref_blob[SIZEOF_REF] = "";
1354 static char ref_commit[SIZEOF_REF] = "HEAD";
1355 static char ref_head[SIZEOF_REF] = "HEAD";
1357 struct view {
1358 const char *name; /* View name */
1359 const char *cmd_fmt; /* Default command line format */
1360 const char *cmd_env; /* Command line set via environment */
1361 const char *id; /* Points to either of ref_{head,commit,blob} */
1363 struct view_ops *ops; /* View operations */
1365 enum keymap keymap; /* What keymap does this view have */
1366 bool git_dir; /* Whether the view requires a git directory. */
1368 char cmd[SIZEOF_STR]; /* Command buffer */
1369 char ref[SIZEOF_REF]; /* Hovered commit reference */
1370 char vid[SIZEOF_REF]; /* View ID. Set to id member when updating. */
1372 int height, width; /* The width and height of the main window */
1373 WINDOW *win; /* The main window */
1374 WINDOW *title; /* The title window living below the main window */
1376 /* Navigation */
1377 unsigned long offset; /* Offset of the window top */
1378 unsigned long lineno; /* Current line number */
1380 /* Searching */
1381 char grep[SIZEOF_STR]; /* Search string */
1382 regex_t *regex; /* Pre-compiled regex */
1384 /* If non-NULL, points to the view that opened this view. If this view
1385 * is closed tig will switch back to the parent view. */
1386 struct view *parent;
1388 /* Buffering */
1389 size_t lines; /* Total number of lines */
1390 struct line *line; /* Line index */
1391 size_t line_alloc; /* Total number of allocated lines */
1392 size_t line_size; /* Total number of used lines */
1393 unsigned int digits; /* Number of digits in the lines member. */
1395 /* Loading */
1396 FILE *pipe;
1397 time_t start_time;
1398 };
1400 struct view_ops {
1401 /* What type of content being displayed. Used in the title bar. */
1402 const char *type;
1403 /* Open and reads in all view content. */
1404 bool (*open)(struct view *view);
1405 /* Read one line; updates view->line. */
1406 bool (*read)(struct view *view, char *data);
1407 /* Draw one line; @lineno must be < view->height. */
1408 bool (*draw)(struct view *view, struct line *line, unsigned int lineno, bool selected);
1409 /* Depending on view handle a special requests. */
1410 enum request (*request)(struct view *view, enum request request, struct line *line);
1411 /* Search for regex in a line. */
1412 bool (*grep)(struct view *view, struct line *line);
1413 /* Select line */
1414 void (*select)(struct view *view, struct line *line);
1415 };
1417 static struct view_ops pager_ops;
1418 static struct view_ops main_ops;
1419 static struct view_ops tree_ops;
1420 static struct view_ops blob_ops;
1421 static struct view_ops blame_ops;
1422 static struct view_ops help_ops;
1423 static struct view_ops status_ops;
1424 static struct view_ops stage_ops;
1426 #define VIEW_STR(name, cmd, env, ref, ops, map, git) \
1427 { name, cmd, #env, ref, ops, map, git }
1429 #define VIEW_(id, name, ops, git, ref) \
1430 VIEW_STR(name, TIG_##id##_CMD, TIG_##id##_CMD, ref, ops, KEYMAP_##id, git)
1433 static struct view views[] = {
1434 VIEW_(MAIN, "main", &main_ops, TRUE, ref_head),
1435 VIEW_(DIFF, "diff", &pager_ops, TRUE, ref_commit),
1436 VIEW_(LOG, "log", &pager_ops, TRUE, ref_head),
1437 VIEW_(TREE, "tree", &tree_ops, TRUE, ref_commit),
1438 VIEW_(BLOB, "blob", &blob_ops, TRUE, ref_blob),
1439 VIEW_(BLAME, "blame", &blame_ops, TRUE, ref_commit),
1440 VIEW_(HELP, "help", &help_ops, FALSE, ""),
1441 VIEW_(PAGER, "pager", &pager_ops, FALSE, "stdin"),
1442 VIEW_(STATUS, "status", &status_ops, TRUE, ""),
1443 VIEW_(STAGE, "stage", &stage_ops, TRUE, ""),
1444 };
1446 #define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
1447 #define VIEW_REQ(view) ((view) - views + REQ_OFFSET + 1)
1449 #define foreach_view(view, i) \
1450 for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
1452 #define view_is_displayed(view) \
1453 (view == display[0] || view == display[1])
1455 static int
1456 draw_text(struct view *view, const char *string, int max_len,
1457 bool use_tilde, bool selected)
1458 {
1459 int len = 0;
1460 int trimmed = FALSE;
1462 if (max_len <= 0)
1463 return 0;
1465 if (opt_utf8) {
1466 len = utf8_length(string, max_len, &trimmed, use_tilde);
1467 } else {
1468 len = strlen(string);
1469 if (len > max_len) {
1470 if (use_tilde) {
1471 max_len -= 1;
1472 }
1473 len = max_len;
1474 trimmed = TRUE;
1475 }
1476 }
1478 waddnstr(view->win, string, len);
1479 if (trimmed && use_tilde) {
1480 if (!selected)
1481 wattrset(view->win, get_line_attr(LINE_DELIMITER));
1482 waddch(view->win, '~');
1483 len++;
1484 }
1486 return len;
1487 }
1489 static int
1490 draw_lineno(struct view *view, unsigned int lineno, int max, bool selected)
1491 {
1492 static char fmt[] = "%1ld";
1493 char number[10] = " ";
1494 int digits3 = view->digits < 3 ? 3 : view->digits;
1495 int max_number = MIN(digits3, STRING_SIZE(number));
1496 bool showtrimmed = FALSE;
1497 int col;
1499 lineno += view->offset + 1;
1500 if (lineno == 1 || (lineno % opt_num_interval) == 0) {
1501 if (view->digits <= 9)
1502 fmt[1] = '0' + digits3;
1504 if (!string_format(number, fmt, lineno))
1505 number[0] = 0;
1506 showtrimmed = TRUE;
1507 }
1509 if (max < max_number)
1510 max_number = max;
1512 if (!selected)
1513 wattrset(view->win, get_line_attr(LINE_LINE_NUMBER));
1514 col = draw_text(view, number, max_number, showtrimmed, selected);
1515 if (col < max) {
1516 if (!selected)
1517 wattrset(view->win, A_NORMAL);
1518 waddch(view->win, ACS_VLINE);
1519 col++;
1520 }
1521 if (col < max) {
1522 waddch(view->win, ' ');
1523 col++;
1524 }
1526 return col;
1527 }
1529 static int
1530 draw_date(struct view *view, struct tm *time, int max, bool selected)
1531 {
1532 char buf[DATE_COLS];
1533 int col;
1534 int timelen = 0;
1536 if (max > DATE_COLS)
1537 max = DATE_COLS;
1538 if (time)
1539 timelen = strftime(buf, sizeof(buf), DATE_FORMAT, time);
1540 if (!timelen) {
1541 memset(buf, ' ', sizeof(buf) - 1);
1542 buf[sizeof(buf) - 1] = 0;
1543 }
1545 if (!selected)
1546 wattrset(view->win, get_line_attr(LINE_DATE));
1547 col = draw_text(view, buf, max, FALSE, selected);
1548 if (col < max) {
1549 if (!selected)
1550 wattrset(view->win, get_line_attr(LINE_DEFAULT));
1551 waddch(view->win, ' ');
1552 col++;
1553 }
1555 return col;
1556 }
1558 static bool
1559 draw_view_line(struct view *view, unsigned int lineno)
1560 {
1561 struct line *line;
1562 bool selected = (view->offset + lineno == view->lineno);
1563 bool draw_ok;
1565 assert(view_is_displayed(view));
1567 if (view->offset + lineno >= view->lines)
1568 return FALSE;
1570 line = &view->line[view->offset + lineno];
1572 wmove(view->win, lineno, 0);
1574 if (selected) {
1575 line->selected = TRUE;
1576 view->ops->select(view, line);
1577 wchgat(view->win, -1, 0, LINE_CURSOR, NULL);
1578 wattrset(view->win, get_line_attr(LINE_CURSOR));
1579 } else if (line->selected) {
1580 line->selected = FALSE;
1581 wclrtoeol(view->win);
1582 }
1584 scrollok(view->win, FALSE);
1585 draw_ok = view->ops->draw(view, line, lineno, selected);
1586 scrollok(view->win, TRUE);
1588 return draw_ok;
1589 }
1591 static void
1592 redraw_view_dirty(struct view *view)
1593 {
1594 bool dirty = FALSE;
1595 int lineno;
1597 for (lineno = 0; lineno < view->height; lineno++) {
1598 struct line *line = &view->line[view->offset + lineno];
1600 if (!line->dirty)
1601 continue;
1602 line->dirty = 0;
1603 dirty = TRUE;
1604 if (!draw_view_line(view, lineno))
1605 break;
1606 }
1608 if (!dirty)
1609 return;
1610 redrawwin(view->win);
1611 if (input_mode)
1612 wnoutrefresh(view->win);
1613 else
1614 wrefresh(view->win);
1615 }
1617 static void
1618 redraw_view_from(struct view *view, int lineno)
1619 {
1620 assert(0 <= lineno && lineno < view->height);
1622 for (; lineno < view->height; lineno++) {
1623 if (!draw_view_line(view, lineno))
1624 break;
1625 }
1627 redrawwin(view->win);
1628 if (input_mode)
1629 wnoutrefresh(view->win);
1630 else
1631 wrefresh(view->win);
1632 }
1634 static void
1635 redraw_view(struct view *view)
1636 {
1637 wclear(view->win);
1638 redraw_view_from(view, 0);
1639 }
1642 static void
1643 update_view_title(struct view *view)
1644 {
1645 char buf[SIZEOF_STR];
1646 char state[SIZEOF_STR];
1647 size_t bufpos = 0, statelen = 0;
1649 assert(view_is_displayed(view));
1651 if (view != VIEW(REQ_VIEW_STATUS) && (view->lines || view->pipe)) {
1652 unsigned int view_lines = view->offset + view->height;
1653 unsigned int lines = view->lines
1654 ? MIN(view_lines, view->lines) * 100 / view->lines
1655 : 0;
1657 string_format_from(state, &statelen, "- %s %d of %d (%d%%)",
1658 view->ops->type,
1659 view->lineno + 1,
1660 view->lines,
1661 lines);
1663 if (view->pipe) {
1664 time_t secs = time(NULL) - view->start_time;
1666 /* Three git seconds are a long time ... */
1667 if (secs > 2)
1668 string_format_from(state, &statelen, " %lds", secs);
1669 }
1670 }
1672 string_format_from(buf, &bufpos, "[%s]", view->name);
1673 if (*view->ref && bufpos < view->width) {
1674 size_t refsize = strlen(view->ref);
1675 size_t minsize = bufpos + 1 + /* abbrev= */ 7 + 1 + statelen;
1677 if (minsize < view->width)
1678 refsize = view->width - minsize + 7;
1679 string_format_from(buf, &bufpos, " %.*s", (int) refsize, view->ref);
1680 }
1682 if (statelen && bufpos < view->width) {
1683 string_format_from(buf, &bufpos, " %s", state);
1684 }
1686 if (view == display[current_view])
1687 wbkgdset(view->title, get_line_attr(LINE_TITLE_FOCUS));
1688 else
1689 wbkgdset(view->title, get_line_attr(LINE_TITLE_BLUR));
1691 mvwaddnstr(view->title, 0, 0, buf, bufpos);
1692 wclrtoeol(view->title);
1693 wmove(view->title, 0, view->width - 1);
1695 if (input_mode)
1696 wnoutrefresh(view->title);
1697 else
1698 wrefresh(view->title);
1699 }
1701 static void
1702 resize_display(void)
1703 {
1704 int offset, i;
1705 struct view *base = display[0];
1706 struct view *view = display[1] ? display[1] : display[0];
1708 /* Setup window dimensions */
1710 getmaxyx(stdscr, base->height, base->width);
1712 /* Make room for the status window. */
1713 base->height -= 1;
1715 if (view != base) {
1716 /* Horizontal split. */
1717 view->width = base->width;
1718 view->height = SCALE_SPLIT_VIEW(base->height);
1719 base->height -= view->height;
1721 /* Make room for the title bar. */
1722 view->height -= 1;
1723 }
1725 /* Make room for the title bar. */
1726 base->height -= 1;
1728 offset = 0;
1730 foreach_displayed_view (view, i) {
1731 if (!view->win) {
1732 view->win = newwin(view->height, 0, offset, 0);
1733 if (!view->win)
1734 die("Failed to create %s view", view->name);
1736 scrollok(view->win, TRUE);
1738 view->title = newwin(1, 0, offset + view->height, 0);
1739 if (!view->title)
1740 die("Failed to create title window");
1742 } else {
1743 wresize(view->win, view->height, view->width);
1744 mvwin(view->win, offset, 0);
1745 mvwin(view->title, offset + view->height, 0);
1746 }
1748 offset += view->height + 1;
1749 }
1750 }
1752 static void
1753 redraw_display(void)
1754 {
1755 struct view *view;
1756 int i;
1758 foreach_displayed_view (view, i) {
1759 redraw_view(view);
1760 update_view_title(view);
1761 }
1762 }
1764 static void
1765 update_display_cursor(struct view *view)
1766 {
1767 /* Move the cursor to the right-most column of the cursor line.
1768 *
1769 * XXX: This could turn out to be a bit expensive, but it ensures that
1770 * the cursor does not jump around. */
1771 if (view->lines) {
1772 wmove(view->win, view->lineno - view->offset, view->width - 1);
1773 wrefresh(view->win);
1774 }
1775 }
1777 /*
1778 * Navigation
1779 */
1781 /* Scrolling backend */
1782 static void
1783 do_scroll_view(struct view *view, int lines)
1784 {
1785 bool redraw_current_line = FALSE;
1787 /* The rendering expects the new offset. */
1788 view->offset += lines;
1790 assert(0 <= view->offset && view->offset < view->lines);
1791 assert(lines);
1793 /* Move current line into the view. */
1794 if (view->lineno < view->offset) {
1795 view->lineno = view->offset;
1796 redraw_current_line = TRUE;
1797 } else if (view->lineno >= view->offset + view->height) {
1798 view->lineno = view->offset + view->height - 1;
1799 redraw_current_line = TRUE;
1800 }
1802 assert(view->offset <= view->lineno && view->lineno < view->lines);
1804 /* Redraw the whole screen if scrolling is pointless. */
1805 if (view->height < ABS(lines)) {
1806 redraw_view(view);
1808 } else {
1809 int line = lines > 0 ? view->height - lines : 0;
1810 int end = line + ABS(lines);
1812 wscrl(view->win, lines);
1814 for (; line < end; line++) {
1815 if (!draw_view_line(view, line))
1816 break;
1817 }
1819 if (redraw_current_line)
1820 draw_view_line(view, view->lineno - view->offset);
1821 }
1823 redrawwin(view->win);
1824 wrefresh(view->win);
1825 report("");
1826 }
1828 /* Scroll frontend */
1829 static void
1830 scroll_view(struct view *view, enum request request)
1831 {
1832 int lines = 1;
1834 assert(view_is_displayed(view));
1836 switch (request) {
1837 case REQ_SCROLL_PAGE_DOWN:
1838 lines = view->height;
1839 case REQ_SCROLL_LINE_DOWN:
1840 if (view->offset + lines > view->lines)
1841 lines = view->lines - view->offset;
1843 if (lines == 0 || view->offset + view->height >= view->lines) {
1844 report("Cannot scroll beyond the last line");
1845 return;
1846 }
1847 break;
1849 case REQ_SCROLL_PAGE_UP:
1850 lines = view->height;
1851 case REQ_SCROLL_LINE_UP:
1852 if (lines > view->offset)
1853 lines = view->offset;
1855 if (lines == 0) {
1856 report("Cannot scroll beyond the first line");
1857 return;
1858 }
1860 lines = -lines;
1861 break;
1863 default:
1864 die("request %d not handled in switch", request);
1865 }
1867 do_scroll_view(view, lines);
1868 }
1870 /* Cursor moving */
1871 static void
1872 move_view(struct view *view, enum request request)
1873 {
1874 int scroll_steps = 0;
1875 int steps;
1877 switch (request) {
1878 case REQ_MOVE_FIRST_LINE:
1879 steps = -view->lineno;
1880 break;
1882 case REQ_MOVE_LAST_LINE:
1883 steps = view->lines - view->lineno - 1;
1884 break;
1886 case REQ_MOVE_PAGE_UP:
1887 steps = view->height > view->lineno
1888 ? -view->lineno : -view->height;
1889 break;
1891 case REQ_MOVE_PAGE_DOWN:
1892 steps = view->lineno + view->height >= view->lines
1893 ? view->lines - view->lineno - 1 : view->height;
1894 break;
1896 case REQ_MOVE_UP:
1897 steps = -1;
1898 break;
1900 case REQ_MOVE_DOWN:
1901 steps = 1;
1902 break;
1904 default:
1905 die("request %d not handled in switch", request);
1906 }
1908 if (steps <= 0 && view->lineno == 0) {
1909 report("Cannot move beyond the first line");
1910 return;
1912 } else if (steps >= 0 && view->lineno + 1 >= view->lines) {
1913 report("Cannot move beyond the last line");
1914 return;
1915 }
1917 /* Move the current line */
1918 view->lineno += steps;
1919 assert(0 <= view->lineno && view->lineno < view->lines);
1921 /* Check whether the view needs to be scrolled */
1922 if (view->lineno < view->offset ||
1923 view->lineno >= view->offset + view->height) {
1924 scroll_steps = steps;
1925 if (steps < 0 && -steps > view->offset) {
1926 scroll_steps = -view->offset;
1928 } else if (steps > 0) {
1929 if (view->lineno == view->lines - 1 &&
1930 view->lines > view->height) {
1931 scroll_steps = view->lines - view->offset - 1;
1932 if (scroll_steps >= view->height)
1933 scroll_steps -= view->height - 1;
1934 }
1935 }
1936 }
1938 if (!view_is_displayed(view)) {
1939 view->offset += scroll_steps;
1940 assert(0 <= view->offset && view->offset < view->lines);
1941 view->ops->select(view, &view->line[view->lineno]);
1942 return;
1943 }
1945 /* Repaint the old "current" line if we be scrolling */
1946 if (ABS(steps) < view->height)
1947 draw_view_line(view, view->lineno - steps - view->offset);
1949 if (scroll_steps) {
1950 do_scroll_view(view, scroll_steps);
1951 return;
1952 }
1954 /* Draw the current line */
1955 draw_view_line(view, view->lineno - view->offset);
1957 redrawwin(view->win);
1958 wrefresh(view->win);
1959 report("");
1960 }
1963 /*
1964 * Searching
1965 */
1967 static void search_view(struct view *view, enum request request);
1969 static bool
1970 find_next_line(struct view *view, unsigned long lineno, struct line *line)
1971 {
1972 assert(view_is_displayed(view));
1974 if (!view->ops->grep(view, line))
1975 return FALSE;
1977 if (lineno - view->offset >= view->height) {
1978 view->offset = lineno;
1979 view->lineno = lineno;
1980 redraw_view(view);
1982 } else {
1983 unsigned long old_lineno = view->lineno - view->offset;
1985 view->lineno = lineno;
1986 draw_view_line(view, old_lineno);
1988 draw_view_line(view, view->lineno - view->offset);
1989 redrawwin(view->win);
1990 wrefresh(view->win);
1991 }
1993 report("Line %ld matches '%s'", lineno + 1, view->grep);
1994 return TRUE;
1995 }
1997 static void
1998 find_next(struct view *view, enum request request)
1999 {
2000 unsigned long lineno = view->lineno;
2001 int direction;
2003 if (!*view->grep) {
2004 if (!*opt_search)
2005 report("No previous search");
2006 else
2007 search_view(view, request);
2008 return;
2009 }
2011 switch (request) {
2012 case REQ_SEARCH:
2013 case REQ_FIND_NEXT:
2014 direction = 1;
2015 break;
2017 case REQ_SEARCH_BACK:
2018 case REQ_FIND_PREV:
2019 direction = -1;
2020 break;
2022 default:
2023 return;
2024 }
2026 if (request == REQ_FIND_NEXT || request == REQ_FIND_PREV)
2027 lineno += direction;
2029 /* Note, lineno is unsigned long so will wrap around in which case it
2030 * will become bigger than view->lines. */
2031 for (; lineno < view->lines; lineno += direction) {
2032 struct line *line = &view->line[lineno];
2034 if (find_next_line(view, lineno, line))
2035 return;
2036 }
2038 report("No match found for '%s'", view->grep);
2039 }
2041 static void
2042 search_view(struct view *view, enum request request)
2043 {
2044 int regex_err;
2046 if (view->regex) {
2047 regfree(view->regex);
2048 *view->grep = 0;
2049 } else {
2050 view->regex = calloc(1, sizeof(*view->regex));
2051 if (!view->regex)
2052 return;
2053 }
2055 regex_err = regcomp(view->regex, opt_search, REG_EXTENDED);
2056 if (regex_err != 0) {
2057 char buf[SIZEOF_STR] = "unknown error";
2059 regerror(regex_err, view->regex, buf, sizeof(buf));
2060 report("Search failed: %s", buf);
2061 return;
2062 }
2064 string_copy(view->grep, opt_search);
2066 find_next(view, request);
2067 }
2069 /*
2070 * Incremental updating
2071 */
2073 static void
2074 end_update(struct view *view)
2075 {
2076 if (!view->pipe)
2077 return;
2078 set_nonblocking_input(FALSE);
2079 if (view->pipe == stdin)
2080 fclose(view->pipe);
2081 else
2082 pclose(view->pipe);
2083 view->pipe = NULL;
2084 }
2086 static bool
2087 begin_update(struct view *view)
2088 {
2089 if (view->pipe)
2090 end_update(view);
2092 if (opt_cmd[0]) {
2093 string_copy(view->cmd, opt_cmd);
2094 opt_cmd[0] = 0;
2095 /* When running random commands, initially show the
2096 * command in the title. However, it maybe later be
2097 * overwritten if a commit line is selected. */
2098 if (view == VIEW(REQ_VIEW_PAGER))
2099 string_copy(view->ref, view->cmd);
2100 else
2101 view->ref[0] = 0;
2103 } else if (view == VIEW(REQ_VIEW_TREE)) {
2104 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
2105 char path[SIZEOF_STR];
2107 if (strcmp(view->vid, view->id))
2108 opt_path[0] = path[0] = 0;
2109 else if (sq_quote(path, 0, opt_path) >= sizeof(path))
2110 return FALSE;
2112 if (!string_format(view->cmd, format, view->id, path))
2113 return FALSE;
2115 } else {
2116 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
2117 const char *id = view->id;
2119 if (!string_format(view->cmd, format, id, id, id, id, id))
2120 return FALSE;
2122 /* Put the current ref_* value to the view title ref
2123 * member. This is needed by the blob view. Most other
2124 * views sets it automatically after loading because the
2125 * first line is a commit line. */
2126 string_copy_rev(view->ref, view->id);
2127 }
2129 /* Special case for the pager view. */
2130 if (opt_pipe) {
2131 view->pipe = opt_pipe;
2132 opt_pipe = NULL;
2133 } else {
2134 view->pipe = popen(view->cmd, "r");
2135 }
2137 if (!view->pipe)
2138 return FALSE;
2140 set_nonblocking_input(TRUE);
2142 view->offset = 0;
2143 view->lines = 0;
2144 view->lineno = 0;
2145 string_copy_rev(view->vid, view->id);
2147 if (view->line) {
2148 int i;
2150 for (i = 0; i < view->lines; i++)
2151 if (view->line[i].data)
2152 free(view->line[i].data);
2154 free(view->line);
2155 view->line = NULL;
2156 }
2158 view->start_time = time(NULL);
2160 return TRUE;
2161 }
2163 #define ITEM_CHUNK_SIZE 256
2164 static void *
2165 realloc_items(void *mem, size_t *size, size_t new_size, size_t item_size)
2166 {
2167 size_t num_chunks = *size / ITEM_CHUNK_SIZE;
2168 size_t num_chunks_new = (new_size + ITEM_CHUNK_SIZE - 1) / ITEM_CHUNK_SIZE;
2170 if (mem == NULL || num_chunks != num_chunks_new) {
2171 *size = num_chunks_new * ITEM_CHUNK_SIZE;
2172 mem = realloc(mem, *size * item_size);
2173 }
2175 return mem;
2176 }
2178 static struct line *
2179 realloc_lines(struct view *view, size_t line_size)
2180 {
2181 size_t alloc = view->line_alloc;
2182 struct line *tmp = realloc_items(view->line, &alloc, line_size,
2183 sizeof(*view->line));
2185 if (!tmp)
2186 return NULL;
2188 view->line = tmp;
2189 view->line_alloc = alloc;
2190 view->line_size = line_size;
2191 return view->line;
2192 }
2194 static bool
2195 update_view(struct view *view)
2196 {
2197 char in_buffer[BUFSIZ];
2198 char out_buffer[BUFSIZ * 2];
2199 char *line;
2200 /* The number of lines to read. If too low it will cause too much
2201 * redrawing (and possible flickering), if too high responsiveness
2202 * will suffer. */
2203 unsigned long lines = view->height;
2204 int redraw_from = -1;
2206 if (!view->pipe)
2207 return TRUE;
2209 /* Only redraw if lines are visible. */
2210 if (view->offset + view->height >= view->lines)
2211 redraw_from = view->lines - view->offset;
2213 /* FIXME: This is probably not perfect for backgrounded views. */
2214 if (!realloc_lines(view, view->lines + lines))
2215 goto alloc_error;
2217 while ((line = fgets(in_buffer, sizeof(in_buffer), view->pipe))) {
2218 size_t linelen = strlen(line);
2220 if (linelen)
2221 line[linelen - 1] = 0;
2223 if (opt_iconv != ICONV_NONE) {
2224 ICONV_CONST char *inbuf = line;
2225 size_t inlen = linelen;
2227 char *outbuf = out_buffer;
2228 size_t outlen = sizeof(out_buffer);
2230 size_t ret;
2232 ret = iconv(opt_iconv, &inbuf, &inlen, &outbuf, &outlen);
2233 if (ret != (size_t) -1) {
2234 line = out_buffer;
2235 linelen = strlen(out_buffer);
2236 }
2237 }
2239 if (!view->ops->read(view, line))
2240 goto alloc_error;
2242 if (lines-- == 1)
2243 break;
2244 }
2246 {
2247 int digits;
2249 lines = view->lines;
2250 for (digits = 0; lines; digits++)
2251 lines /= 10;
2253 /* Keep the displayed view in sync with line number scaling. */
2254 if (digits != view->digits) {
2255 view->digits = digits;
2256 redraw_from = 0;
2257 }
2258 }
2260 if (!view_is_displayed(view))
2261 goto check_pipe;
2263 if (view == VIEW(REQ_VIEW_TREE)) {
2264 /* Clear the view and redraw everything since the tree sorting
2265 * might have rearranged things. */
2266 redraw_view(view);
2268 } else if (redraw_from >= 0) {
2269 /* If this is an incremental update, redraw the previous line
2270 * since for commits some members could have changed when
2271 * loading the main view. */
2272 if (redraw_from > 0)
2273 redraw_from--;
2275 /* Since revision graph visualization requires knowledge
2276 * about the parent commit, it causes a further one-off
2277 * needed to be redrawn for incremental updates. */
2278 if (redraw_from > 0 && opt_rev_graph)
2279 redraw_from--;
2281 /* Incrementally draw avoids flickering. */
2282 redraw_view_from(view, redraw_from);
2283 }
2285 if (view == VIEW(REQ_VIEW_BLAME))
2286 redraw_view_dirty(view);
2288 /* Update the title _after_ the redraw so that if the redraw picks up a
2289 * commit reference in view->ref it'll be available here. */
2290 update_view_title(view);
2292 check_pipe:
2293 if (ferror(view->pipe)) {
2294 report("Failed to read: %s", strerror(errno));
2295 goto end;
2297 } else if (feof(view->pipe)) {
2298 report("");
2299 goto end;
2300 }
2302 return TRUE;
2304 alloc_error:
2305 report("Allocation failure");
2307 end:
2308 if (view->ops->read(view, NULL))
2309 end_update(view);
2310 return FALSE;
2311 }
2313 static struct line *
2314 add_line_data(struct view *view, void *data, enum line_type type)
2315 {
2316 struct line *line = &view->line[view->lines++];
2318 memset(line, 0, sizeof(*line));
2319 line->type = type;
2320 line->data = data;
2322 return line;
2323 }
2325 static struct line *
2326 add_line_text(struct view *view, char *data, enum line_type type)
2327 {
2328 if (data)
2329 data = strdup(data);
2331 return data ? add_line_data(view, data, type) : NULL;
2332 }
2335 /*
2336 * View opening
2337 */
2339 enum open_flags {
2340 OPEN_DEFAULT = 0, /* Use default view switching. */
2341 OPEN_SPLIT = 1, /* Split current view. */
2342 OPEN_BACKGROUNDED = 2, /* Backgrounded. */
2343 OPEN_RELOAD = 4, /* Reload view even if it is the current. */
2344 OPEN_NOMAXIMIZE = 8, /* Do not maximize the current view. */
2345 };
2347 static void
2348 open_view(struct view *prev, enum request request, enum open_flags flags)
2349 {
2350 bool backgrounded = !!(flags & OPEN_BACKGROUNDED);
2351 bool split = !!(flags & OPEN_SPLIT);
2352 bool reload = !!(flags & OPEN_RELOAD);
2353 bool nomaximize = !!(flags & OPEN_NOMAXIMIZE);
2354 struct view *view = VIEW(request);
2355 int nviews = displayed_views();
2356 struct view *base_view = display[0];
2358 if (view == prev && nviews == 1 && !reload) {
2359 report("Already in %s view", view->name);
2360 return;
2361 }
2363 if (view->git_dir && !opt_git_dir[0]) {
2364 report("The %s view is disabled in pager view", view->name);
2365 return;
2366 }
2368 if (split) {
2369 display[1] = view;
2370 if (!backgrounded)
2371 current_view = 1;
2372 } else if (!nomaximize) {
2373 /* Maximize the current view. */
2374 memset(display, 0, sizeof(display));
2375 current_view = 0;
2376 display[current_view] = view;
2377 }
2379 /* Resize the view when switching between split- and full-screen,
2380 * or when switching between two different full-screen views. */
2381 if (nviews != displayed_views() ||
2382 (nviews == 1 && base_view != display[0]))
2383 resize_display();
2385 if (view->ops->open) {
2386 if (!view->ops->open(view)) {
2387 report("Failed to load %s view", view->name);
2388 return;
2389 }
2391 } else if ((reload || strcmp(view->vid, view->id)) &&
2392 !begin_update(view)) {
2393 report("Failed to load %s view", view->name);
2394 return;
2395 }
2397 if (split && prev->lineno - prev->offset >= prev->height) {
2398 /* Take the title line into account. */
2399 int lines = prev->lineno - prev->offset - prev->height + 1;
2401 /* Scroll the view that was split if the current line is
2402 * outside the new limited view. */
2403 do_scroll_view(prev, lines);
2404 }
2406 if (prev && view != prev) {
2407 if (split && !backgrounded) {
2408 /* "Blur" the previous view. */
2409 update_view_title(prev);
2410 }
2412 view->parent = prev;
2413 }
2415 if (view->pipe && view->lines == 0) {
2416 /* Clear the old view and let the incremental updating refill
2417 * the screen. */
2418 werase(view->win);
2419 report("");
2420 } else {
2421 redraw_view(view);
2422 report("");
2423 }
2425 /* If the view is backgrounded the above calls to report()
2426 * won't redraw the view title. */
2427 if (backgrounded)
2428 update_view_title(view);
2429 }
2431 static void
2432 open_external_viewer(const char *cmd)
2433 {
2434 def_prog_mode(); /* save current tty modes */
2435 endwin(); /* restore original tty modes */
2436 system(cmd);
2437 fprintf(stderr, "Press Enter to continue");
2438 getc(stdin);
2439 reset_prog_mode();
2440 redraw_display();
2441 }
2443 static void
2444 open_mergetool(const char *file)
2445 {
2446 char cmd[SIZEOF_STR];
2447 char file_sq[SIZEOF_STR];
2449 if (sq_quote(file_sq, 0, file) < sizeof(file_sq) &&
2450 string_format(cmd, "git mergetool %s", file_sq)) {
2451 open_external_viewer(cmd);
2452 }
2453 }
2455 static void
2456 open_editor(bool from_root, const char *file)
2457 {
2458 char cmd[SIZEOF_STR];
2459 char file_sq[SIZEOF_STR];
2460 char *editor;
2461 char *prefix = from_root ? opt_cdup : "";
2463 editor = getenv("GIT_EDITOR");
2464 if (!editor && *opt_editor)
2465 editor = opt_editor;
2466 if (!editor)
2467 editor = getenv("VISUAL");
2468 if (!editor)
2469 editor = getenv("EDITOR");
2470 if (!editor)
2471 editor = "vi";
2473 if (sq_quote(file_sq, 0, file) < sizeof(file_sq) &&
2474 string_format(cmd, "%s %s%s", editor, prefix, file_sq)) {
2475 open_external_viewer(cmd);
2476 }
2477 }
2479 static void
2480 open_run_request(enum request request)
2481 {
2482 struct run_request *req = get_run_request(request);
2483 char buf[SIZEOF_STR * 2];
2484 size_t bufpos;
2485 char *cmd;
2487 if (!req) {
2488 report("Unknown run request");
2489 return;
2490 }
2492 bufpos = 0;
2493 cmd = req->cmd;
2495 while (cmd) {
2496 char *next = strstr(cmd, "%(");
2497 int len = next - cmd;
2498 char *value;
2500 if (!next) {
2501 len = strlen(cmd);
2502 value = "";
2504 } else if (!strncmp(next, "%(head)", 7)) {
2505 value = ref_head;
2507 } else if (!strncmp(next, "%(commit)", 9)) {
2508 value = ref_commit;
2510 } else if (!strncmp(next, "%(blob)", 7)) {
2511 value = ref_blob;
2513 } else {
2514 report("Unknown replacement in run request: `%s`", req->cmd);
2515 return;
2516 }
2518 if (!string_format_from(buf, &bufpos, "%.*s%s", len, cmd, value))
2519 return;
2521 if (next)
2522 next = strchr(next, ')') + 1;
2523 cmd = next;
2524 }
2526 open_external_viewer(buf);
2527 }
2529 /*
2530 * User request switch noodle
2531 */
2533 static int
2534 view_driver(struct view *view, enum request request)
2535 {
2536 int i;
2538 if (request == REQ_NONE) {
2539 doupdate();
2540 return TRUE;
2541 }
2543 if (request > REQ_NONE) {
2544 open_run_request(request);
2545 /* FIXME: When all views can refresh always do this. */
2546 if (view == VIEW(REQ_VIEW_STATUS) ||
2547 view == VIEW(REQ_VIEW_STAGE))
2548 request = REQ_REFRESH;
2549 else
2550 return TRUE;
2551 }
2553 if (view && view->lines) {
2554 request = view->ops->request(view, request, &view->line[view->lineno]);
2555 if (request == REQ_NONE)
2556 return TRUE;
2557 }
2559 switch (request) {
2560 case REQ_MOVE_UP:
2561 case REQ_MOVE_DOWN:
2562 case REQ_MOVE_PAGE_UP:
2563 case REQ_MOVE_PAGE_DOWN:
2564 case REQ_MOVE_FIRST_LINE:
2565 case REQ_MOVE_LAST_LINE:
2566 move_view(view, request);
2567 break;
2569 case REQ_SCROLL_LINE_DOWN:
2570 case REQ_SCROLL_LINE_UP:
2571 case REQ_SCROLL_PAGE_DOWN:
2572 case REQ_SCROLL_PAGE_UP:
2573 scroll_view(view, request);
2574 break;
2576 case REQ_VIEW_BLAME:
2577 if (!opt_file[0]) {
2578 report("No file chosen, press %s to open tree view",
2579 get_key(REQ_VIEW_TREE));
2580 break;
2581 }
2582 open_view(view, request, OPEN_DEFAULT);
2583 break;
2585 case REQ_VIEW_BLOB:
2586 if (!ref_blob[0]) {
2587 report("No file chosen, press %s to open tree view",
2588 get_key(REQ_VIEW_TREE));
2589 break;
2590 }
2591 open_view(view, request, OPEN_DEFAULT);
2592 break;
2594 case REQ_VIEW_PAGER:
2595 if (!opt_pipe && !VIEW(REQ_VIEW_PAGER)->lines) {
2596 report("No pager content, press %s to run command from prompt",
2597 get_key(REQ_PROMPT));
2598 break;
2599 }
2600 open_view(view, request, OPEN_DEFAULT);
2601 break;
2603 case REQ_VIEW_STAGE:
2604 if (!VIEW(REQ_VIEW_STAGE)->lines) {
2605 report("No stage content, press %s to open the status view and choose file",
2606 get_key(REQ_VIEW_STATUS));
2607 break;
2608 }
2609 open_view(view, request, OPEN_DEFAULT);
2610 break;
2612 case REQ_VIEW_STATUS:
2613 if (opt_is_inside_work_tree == FALSE) {
2614 report("The status view requires a working tree");
2615 break;
2616 }
2617 open_view(view, request, OPEN_DEFAULT);
2618 break;
2620 case REQ_VIEW_MAIN:
2621 case REQ_VIEW_DIFF:
2622 case REQ_VIEW_LOG:
2623 case REQ_VIEW_TREE:
2624 case REQ_VIEW_HELP:
2625 open_view(view, request, OPEN_DEFAULT);
2626 break;
2628 case REQ_NEXT:
2629 case REQ_PREVIOUS:
2630 request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
2632 if ((view == VIEW(REQ_VIEW_DIFF) &&
2633 view->parent == VIEW(REQ_VIEW_MAIN)) ||
2634 (view == VIEW(REQ_VIEW_DIFF) &&
2635 view->parent == VIEW(REQ_VIEW_BLAME)) ||
2636 (view == VIEW(REQ_VIEW_STAGE) &&
2637 view->parent == VIEW(REQ_VIEW_STATUS)) ||
2638 (view == VIEW(REQ_VIEW_BLOB) &&
2639 view->parent == VIEW(REQ_VIEW_TREE))) {
2640 int line;
2642 view = view->parent;
2643 line = view->lineno;
2644 move_view(view, request);
2645 if (view_is_displayed(view))
2646 update_view_title(view);
2647 if (line != view->lineno)
2648 view->ops->request(view, REQ_ENTER,
2649 &view->line[view->lineno]);
2651 } else {
2652 move_view(view, request);
2653 }
2654 break;
2656 case REQ_VIEW_NEXT:
2657 {
2658 int nviews = displayed_views();
2659 int next_view = (current_view + 1) % nviews;
2661 if (next_view == current_view) {
2662 report("Only one view is displayed");
2663 break;
2664 }
2666 current_view = next_view;
2667 /* Blur out the title of the previous view. */
2668 update_view_title(view);
2669 report("");
2670 break;
2671 }
2672 case REQ_REFRESH:
2673 report("Refreshing is not yet supported for the %s view", view->name);
2674 break;
2676 case REQ_MAXIMIZE:
2677 if (displayed_views() == 2)
2678 open_view(view, VIEW_REQ(view), OPEN_DEFAULT);
2679 break;
2681 case REQ_TOGGLE_LINENO:
2682 opt_line_number = !opt_line_number;
2683 redraw_display();
2684 break;
2686 case REQ_TOGGLE_DATE:
2687 opt_date = !opt_date;
2688 redraw_display();
2689 break;
2691 case REQ_TOGGLE_AUTHOR:
2692 opt_author = !opt_author;
2693 redraw_display();
2694 break;
2696 case REQ_TOGGLE_REV_GRAPH:
2697 opt_rev_graph = !opt_rev_graph;
2698 redraw_display();
2699 break;
2701 case REQ_TOGGLE_REFS:
2702 opt_show_refs = !opt_show_refs;
2703 redraw_display();
2704 break;
2706 case REQ_PROMPT:
2707 /* Always reload^Wrerun commands from the prompt. */
2708 open_view(view, opt_request, OPEN_RELOAD);
2709 break;
2711 case REQ_SEARCH:
2712 case REQ_SEARCH_BACK:
2713 search_view(view, request);
2714 break;
2716 case REQ_FIND_NEXT:
2717 case REQ_FIND_PREV:
2718 find_next(view, request);
2719 break;
2721 case REQ_STOP_LOADING:
2722 for (i = 0; i < ARRAY_SIZE(views); i++) {
2723 view = &views[i];
2724 if (view->pipe)
2725 report("Stopped loading the %s view", view->name),
2726 end_update(view);
2727 }
2728 break;
2730 case REQ_SHOW_VERSION:
2731 report("tig-%s (built %s)", TIG_VERSION, __DATE__);
2732 return TRUE;
2734 case REQ_SCREEN_RESIZE:
2735 resize_display();
2736 /* Fall-through */
2737 case REQ_SCREEN_REDRAW:
2738 redraw_display();
2739 break;
2741 case REQ_EDIT:
2742 report("Nothing to edit");
2743 break;
2746 case REQ_ENTER:
2747 report("Nothing to enter");
2748 break;
2751 case REQ_VIEW_CLOSE:
2752 /* XXX: Mark closed views by letting view->parent point to the
2753 * view itself. Parents to closed view should never be
2754 * followed. */
2755 if (view->parent &&
2756 view->parent->parent != view->parent) {
2757 memset(display, 0, sizeof(display));
2758 current_view = 0;
2759 display[current_view] = view->parent;
2760 view->parent = view;
2761 resize_display();
2762 redraw_display();
2763 break;
2764 }
2765 /* Fall-through */
2766 case REQ_QUIT:
2767 return FALSE;
2769 default:
2770 /* An unknown key will show most commonly used commands. */
2771 report("Unknown key, press 'h' for help");
2772 return TRUE;
2773 }
2775 return TRUE;
2776 }
2779 /*
2780 * Pager backend
2781 */
2783 static bool
2784 pager_draw(struct view *view, struct line *line, unsigned int lineno, bool selected)
2785 {
2786 static char spaces[] = " ";
2787 char *text = line->data;
2788 int col = 0;
2790 if (opt_line_number) {
2791 col += draw_lineno(view, lineno, view->width, selected);
2792 if (col >= view->width)
2793 return TRUE;
2794 }
2796 if (!selected)
2797 wattrset(view->win, get_line_attr(line->type));
2799 if (opt_tab_size < TABSIZE) {
2800 int col_offset = col;
2802 col = 0;
2803 while (text && col_offset + col < view->width) {
2804 int cols_max = view->width - col_offset - col;
2805 char *pos = text;
2806 int cols;
2808 if (*text == '\t') {
2809 text++;
2810 assert(sizeof(spaces) > TABSIZE);
2811 pos = spaces;
2812 cols = opt_tab_size - (col % opt_tab_size);
2814 } else {
2815 text = strchr(text, '\t');
2816 cols = line ? text - pos : strlen(pos);
2817 }
2819 waddnstr(view->win, pos, MIN(cols, cols_max));
2820 col += cols;
2821 }
2823 } else {
2824 draw_text(view, text, view->width - col, TRUE, selected);
2825 }
2827 return TRUE;
2828 }
2830 static bool
2831 add_describe_ref(char *buf, size_t *bufpos, char *commit_id, const char *sep)
2832 {
2833 char refbuf[SIZEOF_STR];
2834 char *ref = NULL;
2835 FILE *pipe;
2837 if (!string_format(refbuf, "git describe %s 2>/dev/null", commit_id))
2838 return TRUE;
2840 pipe = popen(refbuf, "r");
2841 if (!pipe)
2842 return TRUE;
2844 if ((ref = fgets(refbuf, sizeof(refbuf), pipe)))
2845 ref = chomp_string(ref);
2846 pclose(pipe);
2848 if (!ref || !*ref)
2849 return TRUE;
2851 /* This is the only fatal call, since it can "corrupt" the buffer. */
2852 if (!string_nformat(buf, SIZEOF_STR, bufpos, "%s%s", sep, ref))
2853 return FALSE;
2855 return TRUE;
2856 }
2858 static void
2859 add_pager_refs(struct view *view, struct line *line)
2860 {
2861 char buf[SIZEOF_STR];
2862 char *commit_id = (char *)line->data + STRING_SIZE("commit ");
2863 struct ref **refs;
2864 size_t bufpos = 0, refpos = 0;
2865 const char *sep = "Refs: ";
2866 bool is_tag = FALSE;
2868 assert(line->type == LINE_COMMIT);
2870 refs = get_refs(commit_id);
2871 if (!refs) {
2872 if (view == VIEW(REQ_VIEW_DIFF))
2873 goto try_add_describe_ref;
2874 return;
2875 }
2877 do {
2878 struct ref *ref = refs[refpos];
2879 char *fmt = ref->tag ? "%s[%s]" :
2880 ref->remote ? "%s<%s>" : "%s%s";
2882 if (!string_format_from(buf, &bufpos, fmt, sep, ref->name))
2883 return;
2884 sep = ", ";
2885 if (ref->tag)
2886 is_tag = TRUE;
2887 } while (refs[refpos++]->next);
2889 if (!is_tag && view == VIEW(REQ_VIEW_DIFF)) {
2890 try_add_describe_ref:
2891 /* Add <tag>-g<commit_id> "fake" reference. */
2892 if (!add_describe_ref(buf, &bufpos, commit_id, sep))
2893 return;
2894 }
2896 if (bufpos == 0)
2897 return;
2899 if (!realloc_lines(view, view->line_size + 1))
2900 return;
2902 add_line_text(view, buf, LINE_PP_REFS);
2903 }
2905 static bool
2906 pager_read(struct view *view, char *data)
2907 {
2908 struct line *line;
2910 if (!data)
2911 return TRUE;
2913 line = add_line_text(view, data, get_line_type(data));
2914 if (!line)
2915 return FALSE;
2917 if (line->type == LINE_COMMIT &&
2918 (view == VIEW(REQ_VIEW_DIFF) ||
2919 view == VIEW(REQ_VIEW_LOG)))
2920 add_pager_refs(view, line);
2922 return TRUE;
2923 }
2925 static enum request
2926 pager_request(struct view *view, enum request request, struct line *line)
2927 {
2928 int split = 0;
2930 if (request != REQ_ENTER)
2931 return request;
2933 if (line->type == LINE_COMMIT &&
2934 (view == VIEW(REQ_VIEW_LOG) ||
2935 view == VIEW(REQ_VIEW_PAGER))) {
2936 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
2937 split = 1;
2938 }
2940 /* Always scroll the view even if it was split. That way
2941 * you can use Enter to scroll through the log view and
2942 * split open each commit diff. */
2943 scroll_view(view, REQ_SCROLL_LINE_DOWN);
2945 /* FIXME: A minor workaround. Scrolling the view will call report("")
2946 * but if we are scrolling a non-current view this won't properly
2947 * update the view title. */
2948 if (split)
2949 update_view_title(view);
2951 return REQ_NONE;
2952 }
2954 static bool
2955 pager_grep(struct view *view, struct line *line)
2956 {
2957 regmatch_t pmatch;
2958 char *text = line->data;
2960 if (!*text)
2961 return FALSE;
2963 if (regexec(view->regex, text, 1, &pmatch, 0) == REG_NOMATCH)
2964 return FALSE;
2966 return TRUE;
2967 }
2969 static void
2970 pager_select(struct view *view, struct line *line)
2971 {
2972 if (line->type == LINE_COMMIT) {
2973 char *text = (char *)line->data + STRING_SIZE("commit ");
2975 if (view != VIEW(REQ_VIEW_PAGER))
2976 string_copy_rev(view->ref, text);
2977 string_copy_rev(ref_commit, text);
2978 }
2979 }
2981 static struct view_ops pager_ops = {
2982 "line",
2983 NULL,
2984 pager_read,
2985 pager_draw,
2986 pager_request,
2987 pager_grep,
2988 pager_select,
2989 };
2992 /*
2993 * Help backend
2994 */
2996 static bool
2997 help_open(struct view *view)
2998 {
2999 char buf[BUFSIZ];
3000 int lines = ARRAY_SIZE(req_info) + 2;
3001 int i;
3003 if (view->lines > 0)
3004 return TRUE;
3006 for (i = 0; i < ARRAY_SIZE(req_info); i++)
3007 if (!req_info[i].request)
3008 lines++;
3010 lines += run_requests + 1;
3012 view->line = calloc(lines, sizeof(*view->line));
3013 if (!view->line)
3014 return FALSE;
3016 add_line_text(view, "Quick reference for tig keybindings:", LINE_DEFAULT);
3018 for (i = 0; i < ARRAY_SIZE(req_info); i++) {
3019 char *key;
3021 if (req_info[i].request == REQ_NONE)
3022 continue;
3024 if (!req_info[i].request) {
3025 add_line_text(view, "", LINE_DEFAULT);
3026 add_line_text(view, req_info[i].help, LINE_DEFAULT);
3027 continue;
3028 }
3030 key = get_key(req_info[i].request);
3031 if (!*key)
3032 key = "(no key defined)";
3034 if (!string_format(buf, " %-25s %s", key, req_info[i].help))
3035 continue;
3037 add_line_text(view, buf, LINE_DEFAULT);
3038 }
3040 if (run_requests) {
3041 add_line_text(view, "", LINE_DEFAULT);
3042 add_line_text(view, "External commands:", LINE_DEFAULT);
3043 }
3045 for (i = 0; i < run_requests; i++) {
3046 struct run_request *req = get_run_request(REQ_NONE + i + 1);
3047 char *key;
3049 if (!req)
3050 continue;
3052 key = get_key_name(req->key);
3053 if (!*key)
3054 key = "(no key defined)";
3056 if (!string_format(buf, " %-10s %-14s `%s`",
3057 keymap_table[req->keymap].name,
3058 key, req->cmd))
3059 continue;
3061 add_line_text(view, buf, LINE_DEFAULT);
3062 }
3064 return TRUE;
3065 }
3067 static struct view_ops help_ops = {
3068 "line",
3069 help_open,
3070 NULL,
3071 pager_draw,
3072 pager_request,
3073 pager_grep,
3074 pager_select,
3075 };
3078 /*
3079 * Tree backend
3080 */
3082 struct tree_stack_entry {
3083 struct tree_stack_entry *prev; /* Entry below this in the stack */
3084 unsigned long lineno; /* Line number to restore */
3085 char *name; /* Position of name in opt_path */
3086 };
3088 /* The top of the path stack. */
3089 static struct tree_stack_entry *tree_stack = NULL;
3090 unsigned long tree_lineno = 0;
3092 static void
3093 pop_tree_stack_entry(void)
3094 {
3095 struct tree_stack_entry *entry = tree_stack;
3097 tree_lineno = entry->lineno;
3098 entry->name[0] = 0;
3099 tree_stack = entry->prev;
3100 free(entry);
3101 }
3103 static void
3104 push_tree_stack_entry(char *name, unsigned long lineno)
3105 {
3106 struct tree_stack_entry *entry = calloc(1, sizeof(*entry));
3107 size_t pathlen = strlen(opt_path);
3109 if (!entry)
3110 return;
3112 entry->prev = tree_stack;
3113 entry->name = opt_path + pathlen;
3114 tree_stack = entry;
3116 if (!string_format_from(opt_path, &pathlen, "%s/", name)) {
3117 pop_tree_stack_entry();
3118 return;
3119 }
3121 /* Move the current line to the first tree entry. */
3122 tree_lineno = 1;
3123 entry->lineno = lineno;
3124 }
3126 /* Parse output from git-ls-tree(1):
3127 *
3128 * 100644 blob fb0e31ea6cc679b7379631188190e975f5789c26 Makefile
3129 * 100644 blob 5304ca4260aaddaee6498f9630e7d471b8591ea6 README
3130 * 100644 blob f931e1d229c3e185caad4449bf5b66ed72462657 tig.c
3131 * 100644 blob ed09fe897f3c7c9af90bcf80cae92558ea88ae38 web.conf
3132 */
3134 #define SIZEOF_TREE_ATTR \
3135 STRING_SIZE("100644 blob ed09fe897f3c7c9af90bcf80cae92558ea88ae38\t")
3137 #define TREE_UP_FORMAT "040000 tree %s\t.."
3139 static int
3140 tree_compare_entry(enum line_type type1, char *name1,
3141 enum line_type type2, char *name2)
3142 {
3143 if (type1 != type2) {
3144 if (type1 == LINE_TREE_DIR)
3145 return -1;
3146 return 1;
3147 }
3149 return strcmp(name1, name2);
3150 }
3152 static char *
3153 tree_path(struct line *line)
3154 {
3155 char *path = line->data;
3157 return path + SIZEOF_TREE_ATTR;
3158 }
3160 static bool
3161 tree_read(struct view *view, char *text)
3162 {
3163 size_t textlen = text ? strlen(text) : 0;
3164 char buf[SIZEOF_STR];
3165 unsigned long pos;
3166 enum line_type type;
3167 bool first_read = view->lines == 0;
3169 if (!text)
3170 return TRUE;
3171 if (textlen <= SIZEOF_TREE_ATTR)
3172 return FALSE;
3174 type = text[STRING_SIZE("100644 ")] == 't'
3175 ? LINE_TREE_DIR : LINE_TREE_FILE;
3177 if (first_read) {
3178 /* Add path info line */
3179 if (!string_format(buf, "Directory path /%s", opt_path) ||
3180 !realloc_lines(view, view->line_size + 1) ||
3181 !add_line_text(view, buf, LINE_DEFAULT))
3182 return FALSE;
3184 /* Insert "link" to parent directory. */
3185 if (*opt_path) {
3186 if (!string_format(buf, TREE_UP_FORMAT, view->ref) ||
3187 !realloc_lines(view, view->line_size + 1) ||
3188 !add_line_text(view, buf, LINE_TREE_DIR))
3189 return FALSE;
3190 }
3191 }
3193 /* Strip the path part ... */
3194 if (*opt_path) {
3195 size_t pathlen = textlen - SIZEOF_TREE_ATTR;
3196 size_t striplen = strlen(opt_path);
3197 char *path = text + SIZEOF_TREE_ATTR;
3199 if (pathlen > striplen)
3200 memmove(path, path + striplen,
3201 pathlen - striplen + 1);
3202 }
3204 /* Skip "Directory ..." and ".." line. */
3205 for (pos = 1 + !!*opt_path; pos < view->lines; pos++) {
3206 struct line *line = &view->line[pos];
3207 char *path1 = tree_path(line);
3208 char *path2 = text + SIZEOF_TREE_ATTR;
3209 int cmp = tree_compare_entry(line->type, path1, type, path2);
3211 if (cmp <= 0)
3212 continue;
3214 text = strdup(text);
3215 if (!text)
3216 return FALSE;
3218 if (view->lines > pos)
3219 memmove(&view->line[pos + 1], &view->line[pos],
3220 (view->lines - pos) * sizeof(*line));
3222 line = &view->line[pos];
3223 line->data = text;
3224 line->type = type;
3225 view->lines++;
3226 return TRUE;
3227 }
3229 if (!add_line_text(view, text, type))
3230 return FALSE;
3232 if (tree_lineno > view->lineno) {
3233 view->lineno = tree_lineno;
3234 tree_lineno = 0;
3235 }
3237 return TRUE;
3238 }
3240 static enum request
3241 tree_request(struct view *view, enum request request, struct line *line)
3242 {
3243 enum open_flags flags;
3245 if (request == REQ_VIEW_BLAME) {
3246 char *filename = tree_path(line);
3248 if (line->type == LINE_TREE_DIR) {
3249 report("Cannot show blame for directory %s", opt_path);
3250 return REQ_NONE;
3251 }
3253 string_copy(opt_ref, view->vid);
3254 string_format(opt_file, "%s%s", opt_path, filename);
3255 return request;
3256 }
3257 if (request == REQ_TREE_PARENT) {
3258 if (*opt_path) {
3259 /* fake 'cd ..' */
3260 request = REQ_ENTER;
3261 line = &view->line[1];
3262 } else {
3263 /* quit view if at top of tree */
3264 return REQ_VIEW_CLOSE;
3265 }
3266 }
3267 if (request != REQ_ENTER)
3268 return request;
3270 /* Cleanup the stack if the tree view is at a different tree. */
3271 while (!*opt_path && tree_stack)
3272 pop_tree_stack_entry();
3274 switch (line->type) {
3275 case LINE_TREE_DIR:
3276 /* Depending on whether it is a subdir or parent (updir?) link
3277 * mangle the path buffer. */
3278 if (line == &view->line[1] && *opt_path) {
3279 pop_tree_stack_entry();
3281 } else {
3282 char *basename = tree_path(line);
3284 push_tree_stack_entry(basename, view->lineno);
3285 }
3287 /* Trees and subtrees share the same ID, so they are not not
3288 * unique like blobs. */
3289 flags = OPEN_RELOAD;
3290 request = REQ_VIEW_TREE;
3291 break;
3293 case LINE_TREE_FILE:
3294 flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
3295 request = REQ_VIEW_BLOB;
3296 break;
3298 default:
3299 return TRUE;
3300 }
3302 open_view(view, request, flags);
3303 if (request == REQ_VIEW_TREE) {
3304 view->lineno = tree_lineno;
3305 }
3307 return REQ_NONE;
3308 }
3310 static void
3311 tree_select(struct view *view, struct line *line)
3312 {
3313 char *text = (char *)line->data + STRING_SIZE("100644 blob ");
3315 if (line->type == LINE_TREE_FILE) {
3316 string_copy_rev(ref_blob, text);
3318 } else if (line->type != LINE_TREE_DIR) {
3319 return;
3320 }
3322 string_copy_rev(view->ref, text);
3323 }
3325 static struct view_ops tree_ops = {
3326 "file",
3327 NULL,
3328 tree_read,
3329 pager_draw,
3330 tree_request,
3331 pager_grep,
3332 tree_select,
3333 };
3335 static bool
3336 blob_read(struct view *view, char *line)
3337 {
3338 if (!line)
3339 return TRUE;
3340 return add_line_text(view, line, LINE_DEFAULT) != NULL;
3341 }
3343 static struct view_ops blob_ops = {
3344 "line",
3345 NULL,
3346 blob_read,
3347 pager_draw,
3348 pager_request,
3349 pager_grep,
3350 pager_select,
3351 };
3353 /*
3354 * Blame backend
3355 *
3356 * Loading the blame view is a two phase job:
3357 *
3358 * 1. File content is read either using opt_file from the
3359 * filesystem or using git-cat-file.
3360 * 2. Then blame information is incrementally added by
3361 * reading output from git-blame.
3362 */
3364 struct blame_commit {
3365 char id[SIZEOF_REV]; /* SHA1 ID. */
3366 char title[128]; /* First line of the commit message. */
3367 char author[75]; /* Author of the commit. */
3368 struct tm time; /* Date from the author ident. */
3369 char filename[128]; /* Name of file. */
3370 };
3372 struct blame {
3373 struct blame_commit *commit;
3374 unsigned int header:1;
3375 char text[1];
3376 };
3378 #define BLAME_CAT_FILE_CMD "git cat-file blob %s:%s"
3379 #define BLAME_INCREMENTAL_CMD "git blame --incremental %s %s"
3381 static bool
3382 blame_open(struct view *view)
3383 {
3384 char path[SIZEOF_STR];
3385 char ref[SIZEOF_STR] = "";
3387 if (sq_quote(path, 0, opt_file) >= sizeof(path))
3388 return FALSE;
3390 if (*opt_ref && sq_quote(ref, 0, opt_ref) >= sizeof(ref))
3391 return FALSE;
3393 if (*opt_ref) {
3394 if (!string_format(view->cmd, BLAME_CAT_FILE_CMD, ref, path))
3395 return FALSE;
3396 } else {
3397 view->pipe = fopen(opt_file, "r");
3398 if (!view->pipe &&
3399 !string_format(view->cmd, BLAME_CAT_FILE_CMD, "HEAD", path))
3400 return FALSE;
3401 }
3403 if (!view->pipe)
3404 view->pipe = popen(view->cmd, "r");
3405 if (!view->pipe)
3406 return FALSE;
3408 if (!string_format(view->cmd, BLAME_INCREMENTAL_CMD, ref, path))
3409 return FALSE;
3411 string_format(view->ref, "%s ...", opt_file);
3412 string_copy_rev(view->vid, opt_file);
3413 set_nonblocking_input(TRUE);
3415 if (view->line) {
3416 int i;
3418 for (i = 0; i < view->lines; i++)
3419 free(view->line[i].data);
3420 free(view->line);
3421 }
3423 view->lines = view->line_alloc = view->line_size = view->lineno = 0;
3424 view->offset = view->lines = view->lineno = 0;
3425 view->line = NULL;
3426 view->start_time = time(NULL);
3428 return TRUE;
3429 }
3431 static struct blame_commit *
3432 get_blame_commit(struct view *view, const char *id)
3433 {
3434 size_t i;
3436 for (i = 0; i < view->lines; i++) {
3437 struct blame *blame = view->line[i].data;
3439 if (!blame->commit)
3440 continue;
3442 if (!strncmp(blame->commit->id, id, SIZEOF_REV - 1))
3443 return blame->commit;
3444 }
3446 {
3447 struct blame_commit *commit = calloc(1, sizeof(*commit));
3449 if (commit)
3450 string_ncopy(commit->id, id, SIZEOF_REV);
3451 return commit;
3452 }
3453 }
3455 static bool
3456 parse_number(char **posref, size_t *number, size_t min, size_t max)
3457 {
3458 char *pos = *posref;
3460 *posref = NULL;
3461 pos = strchr(pos + 1, ' ');
3462 if (!pos || !isdigit(pos[1]))
3463 return FALSE;
3464 *number = atoi(pos + 1);
3465 if (*number < min || *number > max)
3466 return FALSE;
3468 *posref = pos;
3469 return TRUE;
3470 }
3472 static struct blame_commit *
3473 parse_blame_commit(struct view *view, char *text, int *blamed)
3474 {
3475 struct blame_commit *commit;
3476 struct blame *blame;
3477 char *pos = text + SIZEOF_REV - 1;
3478 size_t lineno;
3479 size_t group;
3481 if (strlen(text) <= SIZEOF_REV || *pos != ' ')
3482 return NULL;
3484 if (!parse_number(&pos, &lineno, 1, view->lines) ||
3485 !parse_number(&pos, &group, 1, view->lines - lineno + 1))
3486 return NULL;
3488 commit = get_blame_commit(view, text);
3489 if (!commit)
3490 return NULL;
3492 *blamed += group;
3493 while (group--) {
3494 struct line *line = &view->line[lineno + group - 1];
3496 blame = line->data;
3497 blame->commit = commit;
3498 blame->header = !group;
3499 line->dirty = 1;
3500 }
3502 return commit;
3503 }
3505 static bool
3506 blame_read_file(struct view *view, char *line)
3507 {
3508 if (!line) {
3509 FILE *pipe = NULL;
3511 if (view->lines > 0)
3512 pipe = popen(view->cmd, "r");
3513 else if (!view->parent)
3514 die("No blame exist for %s", view->vid);
3515 view->cmd[0] = 0;
3516 if (!pipe) {
3517 report("Failed to load blame data");
3518 return TRUE;
3519 }
3521 fclose(view->pipe);
3522 view->pipe = pipe;
3523 return FALSE;
3525 } else {
3526 size_t linelen = strlen(line);
3527 struct blame *blame = malloc(sizeof(*blame) + linelen);
3529 if (!line)
3530 return FALSE;
3532 blame->commit = NULL;
3533 strncpy(blame->text, line, linelen);
3534 blame->text[linelen] = 0;
3535 return add_line_data(view, blame, LINE_BLAME_ID) != NULL;
3536 }
3537 }
3539 static bool
3540 match_blame_header(const char *name, char **line)
3541 {
3542 size_t namelen = strlen(name);
3543 bool matched = !strncmp(name, *line, namelen);
3545 if (matched)
3546 *line += namelen;
3548 return matched;
3549 }
3551 static bool
3552 blame_read(struct view *view, char *line)
3553 {
3554 static struct blame_commit *commit = NULL;
3555 static int blamed = 0;
3556 static time_t author_time;
3558 if (*view->cmd)
3559 return blame_read_file(view, line);
3561 if (!line) {
3562 /* Reset all! */
3563 commit = NULL;
3564 blamed = 0;
3565 string_format(view->ref, "%s", view->vid);
3566 if (view_is_displayed(view)) {
3567 update_view_title(view);
3568 redraw_view_from(view, 0);
3569 }
3570 return TRUE;
3571 }
3573 if (!commit) {
3574 commit = parse_blame_commit(view, line, &blamed);
3575 string_format(view->ref, "%s %2d%%", view->vid,
3576 blamed * 100 / view->lines);
3578 } else if (match_blame_header("author ", &line)) {
3579 string_ncopy(commit->author, line, strlen(line));
3581 } else if (match_blame_header("author-time ", &line)) {
3582 author_time = (time_t) atol(line);
3584 } else if (match_blame_header("author-tz ", &line)) {
3585 long tz;
3587 tz = ('0' - line[1]) * 60 * 60 * 10;
3588 tz += ('0' - line[2]) * 60 * 60;
3589 tz += ('0' - line[3]) * 60;
3590 tz += ('0' - line[4]) * 60;
3592 if (line[0] == '-')
3593 tz = -tz;
3595 author_time -= tz;
3596 gmtime_r(&author_time, &commit->time);
3598 } else if (match_blame_header("summary ", &line)) {
3599 string_ncopy(commit->title, line, strlen(line));
3601 } else if (match_blame_header("filename ", &line)) {
3602 string_ncopy(commit->filename, line, strlen(line));
3603 commit = NULL;
3604 }
3606 return TRUE;
3607 }
3609 static bool
3610 blame_draw(struct view *view, struct line *line, unsigned int lineno, bool selected)
3611 {
3612 struct blame *blame = line->data;
3613 int col = 0;
3615 if (opt_date) {
3616 struct tm *time = blame->commit && *blame->commit->filename
3617 ? &blame->commit->time : NULL;
3619 col += draw_date(view, time, view->width, selected);
3620 if (col >= view->width)
3621 return TRUE;
3622 }
3624 if (opt_author) {
3625 int max = MIN(AUTHOR_COLS - 1, view->width - col);
3627 if (!selected)
3628 wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
3629 if (blame->commit)
3630 draw_text(view, blame->commit->author, max, TRUE, selected);
3631 col += AUTHOR_COLS;
3632 if (col >= view->width)
3633 return TRUE;
3634 wmove(view->win, lineno, col);
3635 }
3637 {
3638 int max = MIN(ID_COLS - 1, view->width - col);
3640 if (!selected)
3641 wattrset(view->win, get_line_attr(LINE_BLAME_ID));
3642 if (blame->commit)
3643 draw_text(view, blame->commit->id, max, FALSE, -1);
3644 col += ID_COLS;
3645 if (col >= view->width)
3646 return TRUE;
3647 wmove(view->win, lineno, col);
3648 }
3650 col += draw_lineno(view, lineno, view->width - col, selected);
3651 if (col >= view->width)
3652 return TRUE;
3654 col += draw_text(view, blame->text, view->width - col, TRUE, selected);
3655 return TRUE;
3656 }
3658 static enum request
3659 blame_request(struct view *view, enum request request, struct line *line)
3660 {
3661 enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
3662 struct blame *blame = line->data;
3664 switch (request) {
3665 case REQ_ENTER:
3666 if (!blame->commit) {
3667 report("No commit loaded yet");
3668 break;
3669 }
3671 if (!strcmp(blame->commit->id, NULL_ID)) {
3672 char path[SIZEOF_STR];
3674 if (sq_quote(path, 0, view->vid) >= sizeof(path))
3675 break;
3676 string_format(opt_cmd, "git diff-index --root --patch-with-stat -C -M --cached HEAD -- %s 2>/dev/null", path);
3677 }
3679 open_view(view, REQ_VIEW_DIFF, flags);
3680 break;
3682 default:
3683 return request;
3684 }
3686 return REQ_NONE;
3687 }
3689 static bool
3690 blame_grep(struct view *view, struct line *line)
3691 {
3692 struct blame *blame = line->data;
3693 struct blame_commit *commit = blame->commit;
3694 regmatch_t pmatch;
3696 #define MATCH(text) \
3697 (*text && regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
3699 if (commit) {
3700 char buf[DATE_COLS + 1];
3702 if (MATCH(commit->title) ||
3703 MATCH(commit->author) ||
3704 MATCH(commit->id))
3705 return TRUE;
3707 if (strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time) &&
3708 MATCH(buf))
3709 return TRUE;
3710 }
3712 return MATCH(blame->text);
3714 #undef MATCH
3715 }
3717 static void
3718 blame_select(struct view *view, struct line *line)
3719 {
3720 struct blame *blame = line->data;
3721 struct blame_commit *commit = blame->commit;
3723 if (!commit)
3724 return;
3726 if (!strcmp(commit->id, NULL_ID))
3727 string_ncopy(ref_commit, "HEAD", 4);
3728 else
3729 string_copy_rev(ref_commit, commit->id);
3730 }
3732 static struct view_ops blame_ops = {
3733 "line",
3734 blame_open,
3735 blame_read,
3736 blame_draw,
3737 blame_request,
3738 blame_grep,
3739 blame_select,
3740 };
3742 /*
3743 * Status backend
3744 */
3746 struct status {
3747 char status;
3748 struct {
3749 mode_t mode;
3750 char rev[SIZEOF_REV];
3751 char name[SIZEOF_STR];
3752 } old;
3753 struct {
3754 mode_t mode;
3755 char rev[SIZEOF_REV];
3756 char name[SIZEOF_STR];
3757 } new;
3758 };
3760 static char status_onbranch[SIZEOF_STR];
3761 static struct status stage_status;
3762 static enum line_type stage_line_type;
3764 /* Get fields from the diff line:
3765 * :100644 100644 06a5d6ae9eca55be2e0e585a152e6b1336f2b20e 0000000000000000000000000000000000000000 M
3766 */
3767 static inline bool
3768 status_get_diff(struct status *file, char *buf, size_t bufsize)
3769 {
3770 char *old_mode = buf + 1;
3771 char *new_mode = buf + 8;
3772 char *old_rev = buf + 15;
3773 char *new_rev = buf + 56;
3774 char *status = buf + 97;
3776 if (bufsize < 99 ||
3777 old_mode[-1] != ':' ||
3778 new_mode[-1] != ' ' ||
3779 old_rev[-1] != ' ' ||
3780 new_rev[-1] != ' ' ||
3781 status[-1] != ' ')
3782 return FALSE;
3784 file->status = *status;
3786 string_copy_rev(file->old.rev, old_rev);
3787 string_copy_rev(file->new.rev, new_rev);
3789 file->old.mode = strtoul(old_mode, NULL, 8);
3790 file->new.mode = strtoul(new_mode, NULL, 8);
3792 file->old.name[0] = file->new.name[0] = 0;
3794 return TRUE;
3795 }
3797 static bool
3798 status_run(struct view *view, const char cmd[], char status, enum line_type type)
3799 {
3800 struct status *file = NULL;
3801 struct status *unmerged = NULL;
3802 char buf[SIZEOF_STR * 4];
3803 size_t bufsize = 0;
3804 FILE *pipe;
3806 pipe = popen(cmd, "r");
3807 if (!pipe)
3808 return FALSE;
3810 add_line_data(view, NULL, type);
3812 while (!feof(pipe) && !ferror(pipe)) {
3813 char *sep;
3814 size_t readsize;
3816 readsize = fread(buf + bufsize, 1, sizeof(buf) - bufsize, pipe);
3817 if (!readsize)
3818 break;
3819 bufsize += readsize;
3821 /* Process while we have NUL chars. */
3822 while ((sep = memchr(buf, 0, bufsize))) {
3823 size_t sepsize = sep - buf + 1;
3825 if (!file) {
3826 if (!realloc_lines(view, view->line_size + 1))
3827 goto error_out;
3829 file = calloc(1, sizeof(*file));
3830 if (!file)
3831 goto error_out;
3833 add_line_data(view, file, type);
3834 }
3836 /* Parse diff info part. */
3837 if (status) {
3838 file->status = status;
3839 if (status == 'A')
3840 string_copy(file->old.rev, NULL_ID);
3842 } else if (!file->status) {
3843 if (!status_get_diff(file, buf, sepsize))
3844 goto error_out;
3846 bufsize -= sepsize;
3847 memmove(buf, sep + 1, bufsize);
3849 sep = memchr(buf, 0, bufsize);
3850 if (!sep)
3851 break;
3852 sepsize = sep - buf + 1;
3854 /* Collapse all 'M'odified entries that
3855 * follow a associated 'U'nmerged entry.
3856 */
3857 if (file->status == 'U') {
3858 unmerged = file;
3860 } else if (unmerged) {
3861 int collapse = !strcmp(buf, unmerged->new.name);
3863 unmerged = NULL;
3864 if (collapse) {
3865 free(file);
3866 view->lines--;
3867 continue;
3868 }
3869 }
3870 }
3872 /* Grab the old name for rename/copy. */
3873 if (!*file->old.name &&
3874 (file->status == 'R' || file->status == 'C')) {
3875 sepsize = sep - buf + 1;
3876 string_ncopy(file->old.name, buf, sepsize);
3877 bufsize -= sepsize;
3878 memmove(buf, sep + 1, bufsize);
3880 sep = memchr(buf, 0, bufsize);
3881 if (!sep)
3882 break;
3883 sepsize = sep - buf + 1;
3884 }
3886 /* git-ls-files just delivers a NUL separated
3887 * list of file names similar to the second half
3888 * of the git-diff-* output. */
3889 string_ncopy(file->new.name, buf, sepsize);
3890 if (!*file->old.name)
3891 string_copy(file->old.name, file->new.name);
3892 bufsize -= sepsize;
3893 memmove(buf, sep + 1, bufsize);
3894 file = NULL;
3895 }
3896 }
3898 if (ferror(pipe)) {
3899 error_out:
3900 pclose(pipe);
3901 return FALSE;
3902 }
3904 if (!view->line[view->lines - 1].data)
3905 add_line_data(view, NULL, LINE_STAT_NONE);
3907 pclose(pipe);
3908 return TRUE;
3909 }
3911 /* Don't show unmerged entries in the staged section. */
3912 #define STATUS_DIFF_INDEX_CMD "git diff-index -z --diff-filter=ACDMRTXB --cached -M HEAD"
3913 #define STATUS_DIFF_FILES_CMD "git diff-files -z"
3914 #define STATUS_LIST_OTHER_CMD \
3915 "git ls-files -z --others --exclude-per-directory=.gitignore"
3916 #define STATUS_LIST_NO_HEAD_CMD \
3917 "git ls-files -z --cached --exclude-per-directory=.gitignore"
3919 #define STATUS_DIFF_INDEX_SHOW_CMD \
3920 "git diff-index --root --patch-with-stat -C -M --cached HEAD -- %s %s 2>/dev/null"
3922 #define STATUS_DIFF_FILES_SHOW_CMD \
3923 "git diff-files --root --patch-with-stat -C -M -- %s %s 2>/dev/null"
3925 #define STATUS_DIFF_NO_HEAD_SHOW_CMD \
3926 "git diff --no-color --patch-with-stat /dev/null %s 2>/dev/null"
3928 /* First parse staged info using git-diff-index(1), then parse unstaged
3929 * info using git-diff-files(1), and finally untracked files using
3930 * git-ls-files(1). */
3931 static bool
3932 status_open(struct view *view)
3933 {
3934 struct stat statbuf;
3935 char exclude[SIZEOF_STR];
3936 char indexcmd[SIZEOF_STR] = STATUS_DIFF_INDEX_CMD;
3937 char othercmd[SIZEOF_STR] = STATUS_LIST_OTHER_CMD;
3938 unsigned long prev_lineno = view->lineno;
3939 char indexstatus = 0;
3940 size_t i;
3942 for (i = 0; i < view->lines; i++)
3943 free(view->line[i].data);
3944 free(view->line);
3945 view->lines = view->line_alloc = view->line_size = view->lineno = 0;
3946 view->line = NULL;
3948 if (!realloc_lines(view, view->line_size + 7))
3949 return FALSE;
3951 add_line_data(view, NULL, LINE_STAT_HEAD);
3952 if (opt_no_head)
3953 string_copy(status_onbranch, "Initial commit");
3954 else if (!*opt_head)
3955 string_copy(status_onbranch, "Not currently on any branch");
3956 else if (!string_format(status_onbranch, "On branch %s", opt_head))
3957 return FALSE;
3959 if (opt_no_head) {
3960 string_copy(indexcmd, STATUS_LIST_NO_HEAD_CMD);
3961 indexstatus = 'A';
3962 }
3964 if (!string_format(exclude, "%s/info/exclude", opt_git_dir))
3965 return FALSE;
3967 if (stat(exclude, &statbuf) >= 0) {
3968 size_t cmdsize = strlen(othercmd);
3970 if (!string_format_from(othercmd, &cmdsize, " %s", "--exclude-from=") ||
3971 sq_quote(othercmd, cmdsize, exclude) >= sizeof(othercmd))
3972 return FALSE;
3974 cmdsize = strlen(indexcmd);
3975 if (opt_no_head &&
3976 (!string_format_from(indexcmd, &cmdsize, " %s", "--exclude-from=") ||
3977 sq_quote(indexcmd, cmdsize, exclude) >= sizeof(indexcmd)))
3978 return FALSE;
3979 }
3981 system("git update-index -q --refresh >/dev/null 2>/dev/null");
3983 if (!status_run(view, indexcmd, indexstatus, LINE_STAT_STAGED) ||
3984 !status_run(view, STATUS_DIFF_FILES_CMD, 0, LINE_STAT_UNSTAGED) ||
3985 !status_run(view, othercmd, '?', LINE_STAT_UNTRACKED))
3986 return FALSE;
3988 /* If all went well restore the previous line number to stay in
3989 * the context or select a line with something that can be
3990 * updated. */
3991 if (prev_lineno >= view->lines)
3992 prev_lineno = view->lines - 1;
3993 while (prev_lineno < view->lines && !view->line[prev_lineno].data)
3994 prev_lineno++;
3995 while (prev_lineno > 0 && !view->line[prev_lineno].data)
3996 prev_lineno--;
3998 /* If the above fails, always skip the "On branch" line. */
3999 if (prev_lineno < view->lines)
4000 view->lineno = prev_lineno;
4001 else
4002 view->lineno = 1;
4004 if (view->lineno < view->offset)
4005 view->offset = view->lineno;
4006 else if (view->offset + view->height <= view->lineno)
4007 view->offset = view->lineno - view->height + 1;
4009 return TRUE;
4010 }
4012 static bool
4013 status_draw(struct view *view, struct line *line, unsigned int lineno, bool selected)
4014 {
4015 struct status *status = line->data;
4016 char *text;
4017 int col = 0;
4019 if (selected) {
4020 /* No attributes. */
4022 } else if (line->type == LINE_STAT_HEAD) {
4023 wattrset(view->win, get_line_attr(LINE_STAT_HEAD));
4024 wchgat(view->win, -1, 0, LINE_STAT_HEAD, NULL);
4026 } else if (!status && line->type != LINE_STAT_NONE) {
4027 wattrset(view->win, get_line_attr(LINE_STAT_SECTION));
4028 wchgat(view->win, -1, 0, LINE_STAT_SECTION, NULL);
4030 } else {
4031 wattrset(view->win, get_line_attr(line->type));
4032 }
4034 if (!status) {
4035 switch (line->type) {
4036 case LINE_STAT_STAGED:
4037 text = "Changes to be committed:";
4038 break;
4040 case LINE_STAT_UNSTAGED:
4041 text = "Changed but not updated:";
4042 break;
4044 case LINE_STAT_UNTRACKED:
4045 text = "Untracked files:";
4046 break;
4048 case LINE_STAT_NONE:
4049 text = " (no files)";
4050 break;
4052 case LINE_STAT_HEAD:
4053 text = status_onbranch;
4054 break;
4056 default:
4057 return FALSE;
4058 }
4059 } else {
4060 char buf[] = { status->status, ' ', ' ', ' ', 0 };
4062 col += draw_text(view, buf, view->width, TRUE, selected);
4063 if (!selected)
4064 wattrset(view->win, A_NORMAL);
4065 text = status->new.name;
4066 }
4068 draw_text(view, text, view->width - col, TRUE, selected);
4069 return TRUE;
4070 }
4072 static enum request
4073 status_enter(struct view *view, struct line *line)
4074 {
4075 struct status *status = line->data;
4076 char oldpath[SIZEOF_STR] = "";
4077 char newpath[SIZEOF_STR] = "";
4078 char *info;
4079 size_t cmdsize = 0;
4080 enum open_flags split;
4082 if (line->type == LINE_STAT_NONE ||
4083 (!status && line[1].type == LINE_STAT_NONE)) {
4084 report("No file to diff");
4085 return REQ_NONE;
4086 }
4088 if (status) {
4089 if (sq_quote(oldpath, 0, status->old.name) >= sizeof(oldpath))
4090 return REQ_QUIT;
4091 /* Diffs for unmerged entries are empty when pasing the
4092 * new path, so leave it empty. */
4093 if (status->status != 'U' &&
4094 sq_quote(newpath, 0, status->new.name) >= sizeof(newpath))
4095 return REQ_QUIT;
4096 }
4098 if (opt_cdup[0] &&
4099 line->type != LINE_STAT_UNTRACKED &&
4100 !string_format_from(opt_cmd, &cmdsize, "cd %s;", opt_cdup))
4101 return REQ_QUIT;
4103 switch (line->type) {
4104 case LINE_STAT_STAGED:
4105 if (opt_no_head) {
4106 if (!string_format_from(opt_cmd, &cmdsize,
4107 STATUS_DIFF_NO_HEAD_SHOW_CMD,
4108 newpath))
4109 return REQ_QUIT;
4110 } else {
4111 if (!string_format_from(opt_cmd, &cmdsize,
4112 STATUS_DIFF_INDEX_SHOW_CMD,
4113 oldpath, newpath))
4114 return REQ_QUIT;
4115 }
4117 if (status)
4118 info = "Staged changes to %s";
4119 else
4120 info = "Staged changes";
4121 break;
4123 case LINE_STAT_UNSTAGED:
4124 if (!string_format_from(opt_cmd, &cmdsize,
4125 STATUS_DIFF_FILES_SHOW_CMD, oldpath, newpath))
4126 return REQ_QUIT;
4127 if (status)
4128 info = "Unstaged changes to %s";
4129 else
4130 info = "Unstaged changes";
4131 break;
4133 case LINE_STAT_UNTRACKED:
4134 if (opt_pipe)
4135 return REQ_QUIT;
4137 if (!status) {
4138 report("No file to show");
4139 return REQ_NONE;
4140 }
4142 opt_pipe = fopen(status->new.name, "r");
4143 info = "Untracked file %s";
4144 break;
4146 case LINE_STAT_HEAD:
4147 return REQ_NONE;
4149 default:
4150 die("line type %d not handled in switch", line->type);
4151 }
4153 split = view_is_displayed(view) ? OPEN_SPLIT : 0;
4154 open_view(view, REQ_VIEW_STAGE, OPEN_RELOAD | split);
4155 if (view_is_displayed(VIEW(REQ_VIEW_STAGE))) {
4156 if (status) {
4157 stage_status = *status;
4158 } else {
4159 memset(&stage_status, 0, sizeof(stage_status));
4160 }
4162 stage_line_type = line->type;
4163 string_format(VIEW(REQ_VIEW_STAGE)->ref, info, stage_status.new.name);
4164 }
4166 return REQ_NONE;
4167 }
4169 static bool
4170 status_exists(struct status *status, enum line_type type)
4171 {
4172 struct view *view = VIEW(REQ_VIEW_STATUS);
4173 struct line *line;
4175 for (line = view->line; line < view->line + view->lines; line++) {
4176 struct status *pos = line->data;
4178 if (line->type == type && pos &&
4179 !strcmp(status->new.name, pos->new.name))
4180 return TRUE;
4181 }
4183 return FALSE;
4184 }
4187 static FILE *
4188 status_update_prepare(enum line_type type)
4189 {
4190 char cmd[SIZEOF_STR];
4191 size_t cmdsize = 0;
4193 if (opt_cdup[0] &&
4194 type != LINE_STAT_UNTRACKED &&
4195 !string_format_from(cmd, &cmdsize, "cd %s;", opt_cdup))
4196 return NULL;
4198 switch (type) {
4199 case LINE_STAT_STAGED:
4200 string_add(cmd, cmdsize, "git update-index -z --index-info");
4201 break;
4203 case LINE_STAT_UNSTAGED:
4204 case LINE_STAT_UNTRACKED:
4205 string_add(cmd, cmdsize, "git update-index -z --add --remove --stdin");
4206 break;
4208 default:
4209 die("line type %d not handled in switch", type);
4210 }
4212 return popen(cmd, "w");
4213 }
4215 static bool
4216 status_update_write(FILE *pipe, struct status *status, enum line_type type)
4217 {
4218 char buf[SIZEOF_STR];
4219 size_t bufsize = 0;
4220 size_t written = 0;
4222 switch (type) {
4223 case LINE_STAT_STAGED:
4224 if (!string_format_from(buf, &bufsize, "%06o %s\t%s%c",
4225 status->old.mode,
4226 status->old.rev,
4227 status->old.name, 0))
4228 return FALSE;
4229 break;
4231 case LINE_STAT_UNSTAGED:
4232 case LINE_STAT_UNTRACKED:
4233 if (!string_format_from(buf, &bufsize, "%s%c", status->new.name, 0))
4234 return FALSE;
4235 break;
4237 default:
4238 die("line type %d not handled in switch", type);
4239 }
4241 while (!ferror(pipe) && written < bufsize) {
4242 written += fwrite(buf + written, 1, bufsize - written, pipe);
4243 }
4245 return written == bufsize;
4246 }
4248 static bool
4249 status_update_file(struct status *status, enum line_type type)
4250 {
4251 FILE *pipe = status_update_prepare(type);
4252 bool result;
4254 if (!pipe)
4255 return FALSE;
4257 result = status_update_write(pipe, status, type);
4258 pclose(pipe);
4259 return result;
4260 }
4262 static bool
4263 status_update_files(struct view *view, struct line *line)
4264 {
4265 FILE *pipe = status_update_prepare(line->type);
4266 bool result = TRUE;
4267 struct line *pos = view->line + view->lines;
4268 int files = 0;
4269 int file, done;
4271 if (!pipe)
4272 return FALSE;
4274 for (pos = line; pos < view->line + view->lines && pos->data; pos++)
4275 files++;
4277 for (file = 0, done = 0; result && file < files; line++, file++) {
4278 int almost_done = file * 100 / files;
4280 if (almost_done > done) {
4281 done = almost_done;
4282 string_format(view->ref, "updating file %u of %u (%d%% done)",
4283 file, files, done);
4284 update_view_title(view);
4285 }
4286 result = status_update_write(pipe, line->data, line->type);
4287 }
4289 pclose(pipe);
4290 return result;
4291 }
4293 static bool
4294 status_update(struct view *view)
4295 {
4296 struct line *line = &view->line[view->lineno];
4298 assert(view->lines);
4300 if (!line->data) {
4301 /* This should work even for the "On branch" line. */
4302 if (line < view->line + view->lines && !line[1].data) {
4303 report("Nothing to update");
4304 return FALSE;
4305 }
4307 if (!status_update_files(view, line + 1)) {
4308 report("Failed to update file status");
4309 return FALSE;
4310 }
4312 } else if (!status_update_file(line->data, line->type)) {
4313 report("Failed to update file status");
4314 return FALSE;
4315 }
4317 return TRUE;
4318 }
4320 static enum request
4321 status_request(struct view *view, enum request request, struct line *line)
4322 {
4323 struct status *status = line->data;
4325 switch (request) {
4326 case REQ_STATUS_UPDATE:
4327 if (!status_update(view))
4328 return REQ_NONE;
4329 break;
4331 case REQ_STATUS_MERGE:
4332 if (!status || status->status != 'U') {
4333 report("Merging only possible for files with unmerged status ('U').");
4334 return REQ_NONE;
4335 }
4336 open_mergetool(status->new.name);
4337 break;
4339 case REQ_EDIT:
4340 if (!status)
4341 return request;
4343 open_editor(status->status != '?', status->new.name);
4344 break;
4346 case REQ_VIEW_BLAME:
4347 if (status) {
4348 string_copy(opt_file, status->new.name);
4349 opt_ref[0] = 0;
4350 }
4351 return request;
4353 case REQ_ENTER:
4354 /* After returning the status view has been split to
4355 * show the stage view. No further reloading is
4356 * necessary. */
4357 status_enter(view, line);
4358 return REQ_NONE;
4360 case REQ_REFRESH:
4361 /* Simply reload the view. */
4362 break;
4364 default:
4365 return request;
4366 }
4368 open_view(view, REQ_VIEW_STATUS, OPEN_RELOAD);
4370 return REQ_NONE;
4371 }
4373 static void
4374 status_select(struct view *view, struct line *line)
4375 {
4376 struct status *status = line->data;
4377 char file[SIZEOF_STR] = "all files";
4378 char *text;
4379 char *key;
4381 if (status && !string_format(file, "'%s'", status->new.name))
4382 return;
4384 if (!status && line[1].type == LINE_STAT_NONE)
4385 line++;
4387 switch (line->type) {
4388 case LINE_STAT_STAGED:
4389 text = "Press %s to unstage %s for commit";
4390 break;
4392 case LINE_STAT_UNSTAGED:
4393 text = "Press %s to stage %s for commit";
4394 break;
4396 case LINE_STAT_UNTRACKED:
4397 text = "Press %s to stage %s for addition";
4398 break;
4400 case LINE_STAT_HEAD:
4401 case LINE_STAT_NONE:
4402 text = "Nothing to update";
4403 break;
4405 default:
4406 die("line type %d not handled in switch", line->type);
4407 }
4409 if (status && status->status == 'U') {
4410 text = "Press %s to resolve conflict in %s";
4411 key = get_key(REQ_STATUS_MERGE);
4413 } else {
4414 key = get_key(REQ_STATUS_UPDATE);
4415 }
4417 string_format(view->ref, text, key, file);
4418 }
4420 static bool
4421 status_grep(struct view *view, struct line *line)
4422 {
4423 struct status *status = line->data;
4424 enum { S_STATUS, S_NAME, S_END } state;
4425 char buf[2] = "?";
4426 regmatch_t pmatch;
4428 if (!status)
4429 return FALSE;
4431 for (state = S_STATUS; state < S_END; state++) {
4432 char *text;
4434 switch (state) {
4435 case S_NAME: text = status->new.name; break;
4436 case S_STATUS:
4437 buf[0] = status->status;
4438 text = buf;
4439 break;
4441 default:
4442 return FALSE;
4443 }
4445 if (regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
4446 return TRUE;
4447 }
4449 return FALSE;
4450 }
4452 static struct view_ops status_ops = {
4453 "file",
4454 status_open,
4455 NULL,
4456 status_draw,
4457 status_request,
4458 status_grep,
4459 status_select,
4460 };
4463 static bool
4464 stage_diff_line(FILE *pipe, struct line *line)
4465 {
4466 char *buf = line->data;
4467 size_t bufsize = strlen(buf);
4468 size_t written = 0;
4470 while (!ferror(pipe) && written < bufsize) {
4471 written += fwrite(buf + written, 1, bufsize - written, pipe);
4472 }
4474 fputc('\n', pipe);
4476 return written == bufsize;
4477 }
4479 static bool
4480 stage_diff_write(FILE *pipe, struct line *line, struct line *end)
4481 {
4482 while (line < end) {
4483 if (!stage_diff_line(pipe, line++))
4484 return FALSE;
4485 if (line->type == LINE_DIFF_CHUNK ||
4486 line->type == LINE_DIFF_HEADER)
4487 break;
4488 }
4490 return TRUE;
4491 }
4493 static struct line *
4494 stage_diff_find(struct view *view, struct line *line, enum line_type type)
4495 {
4496 for (; view->line < line; line--)
4497 if (line->type == type)
4498 return line;
4500 return NULL;
4501 }
4503 static bool
4504 stage_update_chunk(struct view *view, struct line *chunk)
4505 {
4506 char cmd[SIZEOF_STR];
4507 size_t cmdsize = 0;
4508 struct line *diff_hdr;
4509 FILE *pipe;
4511 diff_hdr = stage_diff_find(view, chunk, LINE_DIFF_HEADER);
4512 if (!diff_hdr)
4513 return FALSE;
4515 if (opt_cdup[0] &&
4516 !string_format_from(cmd, &cmdsize, "cd %s;", opt_cdup))
4517 return FALSE;
4519 if (!string_format_from(cmd, &cmdsize,
4520 "git apply --whitespace=nowarn --cached %s - && "
4521 "git update-index -q --unmerged --refresh 2>/dev/null",
4522 stage_line_type == LINE_STAT_STAGED ? "-R" : ""))
4523 return FALSE;
4525 pipe = popen(cmd, "w");
4526 if (!pipe)
4527 return FALSE;
4529 if (!stage_diff_write(pipe, diff_hdr, chunk) ||
4530 !stage_diff_write(pipe, chunk, view->line + view->lines))
4531 chunk = NULL;
4533 pclose(pipe);
4535 return chunk ? TRUE : FALSE;
4536 }
4538 static bool
4539 stage_update(struct view *view, struct line *line)
4540 {
4541 struct line *chunk = NULL;
4543 if (!opt_no_head && stage_line_type != LINE_STAT_UNTRACKED)
4544 chunk = stage_diff_find(view, line, LINE_DIFF_CHUNK);
4546 if (chunk) {
4547 if (!stage_update_chunk(view, chunk)) {
4548 report("Failed to apply chunk");
4549 return FALSE;
4550 }
4552 } else if (!stage_status.status) {
4553 view = VIEW(REQ_VIEW_STATUS);
4555 for (line = view->line; line < view->line + view->lines; line++)
4556 if (line->type == stage_line_type)
4557 break;
4559 if (!status_update_files(view, line + 1)) {
4560 report("Failed to update files");
4561 return FALSE;
4562 }
4564 } else if (!status_update_file(&stage_status, stage_line_type)) {
4565 report("Failed to update file");
4566 return FALSE;
4567 }
4569 return TRUE;
4570 }
4572 static enum request
4573 stage_request(struct view *view, enum request request, struct line *line)
4574 {
4575 switch (request) {
4576 case REQ_STATUS_UPDATE:
4577 if (!stage_update(view, line))
4578 return REQ_NONE;
4579 break;
4581 case REQ_EDIT:
4582 if (!stage_status.new.name[0])
4583 return request;
4585 open_editor(stage_status.status != '?', stage_status.new.name);
4586 break;
4588 case REQ_REFRESH:
4589 /* Reload everything ... */
4590 break;
4592 case REQ_VIEW_BLAME:
4593 if (stage_status.new.name[0]) {
4594 string_copy(opt_file, stage_status.new.name);
4595 opt_ref[0] = 0;
4596 }
4597 return request;
4599 case REQ_ENTER:
4600 return pager_request(view, request, line);
4602 default:
4603 return request;
4604 }
4606 open_view(view, REQ_VIEW_STATUS, OPEN_RELOAD | OPEN_NOMAXIMIZE);
4608 /* Check whether the staged entry still exists, and close the
4609 * stage view if it doesn't. */
4610 if (!status_exists(&stage_status, stage_line_type))
4611 return REQ_VIEW_CLOSE;
4613 if (stage_line_type == LINE_STAT_UNTRACKED)
4614 opt_pipe = fopen(stage_status.new.name, "r");
4615 else
4616 string_copy(opt_cmd, view->cmd);
4617 open_view(view, REQ_VIEW_STAGE, OPEN_RELOAD | OPEN_NOMAXIMIZE);
4619 return REQ_NONE;
4620 }
4622 static struct view_ops stage_ops = {
4623 "line",
4624 NULL,
4625 pager_read,
4626 pager_draw,
4627 stage_request,
4628 pager_grep,
4629 pager_select,
4630 };
4633 /*
4634 * Revision graph
4635 */
4637 struct commit {
4638 char id[SIZEOF_REV]; /* SHA1 ID. */
4639 char title[128]; /* First line of the commit message. */
4640 char author[75]; /* Author of the commit. */
4641 struct tm time; /* Date from the author ident. */
4642 struct ref **refs; /* Repository references. */
4643 chtype graph[SIZEOF_REVGRAPH]; /* Ancestry chain graphics. */
4644 size_t graph_size; /* The width of the graph array. */
4645 bool has_parents; /* Rewritten --parents seen. */
4646 };
4648 /* Size of rev graph with no "padding" columns */
4649 #define SIZEOF_REVITEMS (SIZEOF_REVGRAPH - (SIZEOF_REVGRAPH / 2))
4651 struct rev_graph {
4652 struct rev_graph *prev, *next, *parents;
4653 char rev[SIZEOF_REVITEMS][SIZEOF_REV];
4654 size_t size;
4655 struct commit *commit;
4656 size_t pos;
4657 unsigned int boundary:1;
4658 };
4660 /* Parents of the commit being visualized. */
4661 static struct rev_graph graph_parents[4];
4663 /* The current stack of revisions on the graph. */
4664 static struct rev_graph graph_stacks[4] = {
4665 { &graph_stacks[3], &graph_stacks[1], &graph_parents[0] },
4666 { &graph_stacks[0], &graph_stacks[2], &graph_parents[1] },
4667 { &graph_stacks[1], &graph_stacks[3], &graph_parents[2] },
4668 { &graph_stacks[2], &graph_stacks[0], &graph_parents[3] },
4669 };
4671 static inline bool
4672 graph_parent_is_merge(struct rev_graph *graph)
4673 {
4674 return graph->parents->size > 1;
4675 }
4677 static inline void
4678 append_to_rev_graph(struct rev_graph *graph, chtype symbol)
4679 {
4680 struct commit *commit = graph->commit;
4682 if (commit->graph_size < ARRAY_SIZE(commit->graph) - 1)
4683 commit->graph[commit->graph_size++] = symbol;
4684 }
4686 static void
4687 done_rev_graph(struct rev_graph *graph)
4688 {
4689 if (graph_parent_is_merge(graph) &&
4690 graph->pos < graph->size - 1 &&
4691 graph->next->size == graph->size + graph->parents->size - 1) {
4692 size_t i = graph->pos + graph->parents->size - 1;
4694 graph->commit->graph_size = i * 2;
4695 while (i < graph->next->size - 1) {
4696 append_to_rev_graph(graph, ' ');
4697 append_to_rev_graph(graph, '\\');
4698 i++;
4699 }
4700 }
4702 graph->size = graph->pos = 0;
4703 graph->commit = NULL;
4704 memset(graph->parents, 0, sizeof(*graph->parents));
4705 }
4707 static void
4708 push_rev_graph(struct rev_graph *graph, char *parent)
4709 {
4710 int i;
4712 /* "Collapse" duplicate parents lines.
4713 *
4714 * FIXME: This needs to also update update the drawn graph but
4715 * for now it just serves as a method for pruning graph lines. */
4716 for (i = 0; i < graph->size; i++)
4717 if (!strncmp(graph->rev[i], parent, SIZEOF_REV))
4718 return;
4720 if (graph->size < SIZEOF_REVITEMS) {
4721 string_copy_rev(graph->rev[graph->size++], parent);
4722 }
4723 }
4725 static chtype
4726 get_rev_graph_symbol(struct rev_graph *graph)
4727 {
4728 chtype symbol;
4730 if (graph->boundary)
4731 symbol = REVGRAPH_BOUND;
4732 else if (graph->parents->size == 0)
4733 symbol = REVGRAPH_INIT;
4734 else if (graph_parent_is_merge(graph))
4735 symbol = REVGRAPH_MERGE;
4736 else if (graph->pos >= graph->size)
4737 symbol = REVGRAPH_BRANCH;
4738 else
4739 symbol = REVGRAPH_COMMIT;
4741 return symbol;
4742 }
4744 static void
4745 draw_rev_graph(struct rev_graph *graph)
4746 {
4747 struct rev_filler {
4748 chtype separator, line;
4749 };
4750 enum { DEFAULT, RSHARP, RDIAG, LDIAG };
4751 static struct rev_filler fillers[] = {
4752 { ' ', REVGRAPH_LINE },
4753 { '`', '.' },
4754 { '\'', ' ' },
4755 { '/', ' ' },
4756 };
4757 chtype symbol = get_rev_graph_symbol(graph);
4758 struct rev_filler *filler;
4759 size_t i;
4761 filler = &fillers[DEFAULT];
4763 for (i = 0; i < graph->pos; i++) {
4764 append_to_rev_graph(graph, filler->line);
4765 if (graph_parent_is_merge(graph->prev) &&
4766 graph->prev->pos == i)
4767 filler = &fillers[RSHARP];
4769 append_to_rev_graph(graph, filler->separator);
4770 }
4772 /* Place the symbol for this revision. */
4773 append_to_rev_graph(graph, symbol);
4775 if (graph->prev->size > graph->size)
4776 filler = &fillers[RDIAG];
4777 else
4778 filler = &fillers[DEFAULT];
4780 i++;
4782 for (; i < graph->size; i++) {
4783 append_to_rev_graph(graph, filler->separator);
4784 append_to_rev_graph(graph, filler->line);
4785 if (graph_parent_is_merge(graph->prev) &&
4786 i < graph->prev->pos + graph->parents->size)
4787 filler = &fillers[RSHARP];
4788 if (graph->prev->size > graph->size)
4789 filler = &fillers[LDIAG];
4790 }
4792 if (graph->prev->size > graph->size) {
4793 append_to_rev_graph(graph, filler->separator);
4794 if (filler->line != ' ')
4795 append_to_rev_graph(graph, filler->line);
4796 }
4797 }
4799 /* Prepare the next rev graph */
4800 static void
4801 prepare_rev_graph(struct rev_graph *graph)
4802 {
4803 size_t i;
4805 /* First, traverse all lines of revisions up to the active one. */
4806 for (graph->pos = 0; graph->pos < graph->size; graph->pos++) {
4807 if (!strcmp(graph->rev[graph->pos], graph->commit->id))
4808 break;
4810 push_rev_graph(graph->next, graph->rev[graph->pos]);
4811 }
4813 /* Interleave the new revision parent(s). */
4814 for (i = 0; !graph->boundary && i < graph->parents->size; i++)
4815 push_rev_graph(graph->next, graph->parents->rev[i]);
4817 /* Lastly, put any remaining revisions. */
4818 for (i = graph->pos + 1; i < graph->size; i++)
4819 push_rev_graph(graph->next, graph->rev[i]);
4820 }
4822 static void
4823 update_rev_graph(struct rev_graph *graph)
4824 {
4825 /* If this is the finalizing update ... */
4826 if (graph->commit)
4827 prepare_rev_graph(graph);
4829 /* Graph visualization needs a one rev look-ahead,
4830 * so the first update doesn't visualize anything. */
4831 if (!graph->prev->commit)
4832 return;
4834 draw_rev_graph(graph->prev);
4835 done_rev_graph(graph->prev->prev);
4836 }
4839 /*
4840 * Main view backend
4841 */
4843 static bool
4844 main_draw(struct view *view, struct line *line, unsigned int lineno, bool selected)
4845 {
4846 struct commit *commit = line->data;
4847 enum line_type type;
4848 int col = 0;
4850 if (!*commit->author)
4851 return FALSE;
4853 if (selected) {
4854 type = LINE_CURSOR;
4855 } else {
4856 type = LINE_MAIN_COMMIT;
4857 }
4859 if (opt_date) {
4860 col += draw_date(view, &commit->time, view->width, selected);
4861 if (col >= view->width)
4862 return TRUE;
4863 }
4864 if (type != LINE_CURSOR)
4865 wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
4867 if (opt_author) {
4868 int max_len;
4870 max_len = view->width - col;
4871 if (max_len > AUTHOR_COLS - 1)
4872 max_len = AUTHOR_COLS - 1;
4873 draw_text(view, commit->author, max_len, TRUE, selected);
4874 col += AUTHOR_COLS;
4875 if (col >= view->width)
4876 return TRUE;
4877 }
4879 if (opt_rev_graph && commit->graph_size) {
4880 size_t graph_size = view->width - col;
4881 size_t i;
4883 if (type != LINE_CURSOR)
4884 wattrset(view->win, get_line_attr(LINE_MAIN_REVGRAPH));
4885 wmove(view->win, lineno, col);
4886 if (graph_size > commit->graph_size)
4887 graph_size = commit->graph_size;
4888 /* Using waddch() instead of waddnstr() ensures that
4889 * they'll be rendered correctly for the cursor line. */
4890 for (i = 0; i < graph_size; i++)
4891 waddch(view->win, commit->graph[i]);
4893 col += commit->graph_size + 1;
4894 if (col >= view->width)
4895 return TRUE;
4896 waddch(view->win, ' ');
4897 }
4898 if (type != LINE_CURSOR)
4899 wattrset(view->win, A_NORMAL);
4901 wmove(view->win, lineno, col);
4903 if (opt_show_refs && commit->refs) {
4904 size_t i = 0;
4906 do {
4907 if (type == LINE_CURSOR)
4908 ;
4909 else if (commit->refs[i]->head)
4910 wattrset(view->win, get_line_attr(LINE_MAIN_HEAD));
4911 else if (commit->refs[i]->ltag)
4912 wattrset(view->win, get_line_attr(LINE_MAIN_LOCAL_TAG));
4913 else if (commit->refs[i]->tag)
4914 wattrset(view->win, get_line_attr(LINE_MAIN_TAG));
4915 else if (commit->refs[i]->tracked)
4916 wattrset(view->win, get_line_attr(LINE_MAIN_TRACKED));
4917 else if (commit->refs[i]->remote)
4918 wattrset(view->win, get_line_attr(LINE_MAIN_REMOTE));
4919 else
4920 wattrset(view->win, get_line_attr(LINE_MAIN_REF));
4922 col += draw_text(view, "[", view->width - col, TRUE, selected);
4923 col += draw_text(view, commit->refs[i]->name, view->width - col,
4924 TRUE, selected);
4925 col += draw_text(view, "]", view->width - col, TRUE, selected);
4926 if (type != LINE_CURSOR)
4927 wattrset(view->win, A_NORMAL);
4928 col += draw_text(view, " ", view->width - col, TRUE, selected);
4929 if (col >= view->width)
4930 return TRUE;
4931 } while (commit->refs[i++]->next);
4932 }
4934 if (type != LINE_CURSOR)
4935 wattrset(view->win, get_line_attr(type));
4937 draw_text(view, commit->title, view->width - col, TRUE, selected);
4938 return TRUE;
4939 }
4941 /* Reads git log --pretty=raw output and parses it into the commit struct. */
4942 static bool
4943 main_read(struct view *view, char *line)
4944 {
4945 static struct rev_graph *graph = graph_stacks;
4946 enum line_type type;
4947 struct commit *commit;
4949 if (!line) {
4950 if (!view->lines && !view->parent)
4951 die("No revisions match the given arguments.");
4952 update_rev_graph(graph);
4953 return TRUE;
4954 }
4956 type = get_line_type(line);
4957 if (type == LINE_COMMIT) {
4958 commit = calloc(1, sizeof(struct commit));
4959 if (!commit)
4960 return FALSE;
4962 line += STRING_SIZE("commit ");
4963 if (*line == '-') {
4964 graph->boundary = 1;
4965 line++;
4966 }
4968 string_copy_rev(commit->id, line);
4969 commit->refs = get_refs(commit->id);
4970 graph->commit = commit;
4971 add_line_data(view, commit, LINE_MAIN_COMMIT);
4973 while ((line = strchr(line, ' '))) {
4974 line++;
4975 push_rev_graph(graph->parents, line);
4976 commit->has_parents = TRUE;
4977 }
4978 return TRUE;
4979 }
4981 if (!view->lines)
4982 return TRUE;
4983 commit = view->line[view->lines - 1].data;
4985 switch (type) {
4986 case LINE_PARENT:
4987 if (commit->has_parents)
4988 break;
4989 push_rev_graph(graph->parents, line + STRING_SIZE("parent "));
4990 break;
4992 case LINE_AUTHOR:
4993 {
4994 /* Parse author lines where the name may be empty:
4995 * author <email@address.tld> 1138474660 +0100
4996 */
4997 char *ident = line + STRING_SIZE("author ");
4998 char *nameend = strchr(ident, '<');
4999 char *emailend = strchr(ident, '>');
5001 if (!nameend || !emailend)
5002 break;
5004 update_rev_graph(graph);
5005 graph = graph->next;
5007 *nameend = *emailend = 0;
5008 ident = chomp_string(ident);
5009 if (!*ident) {
5010 ident = chomp_string(nameend + 1);
5011 if (!*ident)
5012 ident = "Unknown";
5013 }
5015 string_ncopy(commit->author, ident, strlen(ident));
5017 /* Parse epoch and timezone */
5018 if (emailend[1] == ' ') {
5019 char *secs = emailend + 2;
5020 char *zone = strchr(secs, ' ');
5021 time_t time = (time_t) atol(secs);
5023 if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
5024 long tz;
5026 zone++;
5027 tz = ('0' - zone[1]) * 60 * 60 * 10;
5028 tz += ('0' - zone[2]) * 60 * 60;
5029 tz += ('0' - zone[3]) * 60;
5030 tz += ('0' - zone[4]) * 60;
5032 if (zone[0] == '-')
5033 tz = -tz;
5035 time -= tz;
5036 }
5038 gmtime_r(&time, &commit->time);
5039 }
5040 break;
5041 }
5042 default:
5043 /* Fill in the commit title if it has not already been set. */
5044 if (commit->title[0])
5045 break;
5047 /* Require titles to start with a non-space character at the
5048 * offset used by git log. */
5049 if (strncmp(line, " ", 4))
5050 break;
5051 line += 4;
5052 /* Well, if the title starts with a whitespace character,
5053 * try to be forgiving. Otherwise we end up with no title. */
5054 while (isspace(*line))
5055 line++;
5056 if (*line == '\0')
5057 break;
5058 /* FIXME: More graceful handling of titles; append "..." to
5059 * shortened titles, etc. */
5061 string_ncopy(commit->title, line, strlen(line));
5062 }
5064 return TRUE;
5065 }
5067 static enum request
5068 main_request(struct view *view, enum request request, struct line *line)
5069 {
5070 enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
5072 if (request == REQ_ENTER)
5073 open_view(view, REQ_VIEW_DIFF, flags);
5074 else
5075 return request;
5077 return REQ_NONE;
5078 }
5080 static bool
5081 main_grep(struct view *view, struct line *line)
5082 {
5083 struct commit *commit = line->data;
5084 enum { S_TITLE, S_AUTHOR, S_DATE, S_END } state;
5085 char buf[DATE_COLS + 1];
5086 regmatch_t pmatch;
5088 for (state = S_TITLE; state < S_END; state++) {
5089 char *text;
5091 switch (state) {
5092 case S_TITLE: text = commit->title; break;
5093 case S_AUTHOR: text = commit->author; break;
5094 case S_DATE:
5095 if (!strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time))
5096 continue;
5097 text = buf;
5098 break;
5100 default:
5101 return FALSE;
5102 }
5104 if (regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
5105 return TRUE;
5106 }
5108 return FALSE;
5109 }
5111 static void
5112 main_select(struct view *view, struct line *line)
5113 {
5114 struct commit *commit = line->data;
5116 string_copy_rev(view->ref, commit->id);
5117 string_copy_rev(ref_commit, view->ref);
5118 }
5120 static struct view_ops main_ops = {
5121 "commit",
5122 NULL,
5123 main_read,
5124 main_draw,
5125 main_request,
5126 main_grep,
5127 main_select,
5128 };
5131 /*
5132 * Unicode / UTF-8 handling
5133 *
5134 * NOTE: Much of the following code for dealing with unicode is derived from
5135 * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
5136 * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
5137 */
5139 /* I've (over)annotated a lot of code snippets because I am not entirely
5140 * confident that the approach taken by this small UTF-8 interface is correct.
5141 * --jonas */
5143 static inline int
5144 unicode_width(unsigned long c)
5145 {
5146 if (c >= 0x1100 &&
5147 (c <= 0x115f /* Hangul Jamo */
5148 || c == 0x2329
5149 || c == 0x232a
5150 || (c >= 0x2e80 && c <= 0xa4cf && c != 0x303f)
5151 /* CJK ... Yi */
5152 || (c >= 0xac00 && c <= 0xd7a3) /* Hangul Syllables */
5153 || (c >= 0xf900 && c <= 0xfaff) /* CJK Compatibility Ideographs */
5154 || (c >= 0xfe30 && c <= 0xfe6f) /* CJK Compatibility Forms */
5155 || (c >= 0xff00 && c <= 0xff60) /* Fullwidth Forms */
5156 || (c >= 0xffe0 && c <= 0xffe6)
5157 || (c >= 0x20000 && c <= 0x2fffd)
5158 || (c >= 0x30000 && c <= 0x3fffd)))
5159 return 2;
5161 if (c == '\t')
5162 return opt_tab_size;
5164 return 1;
5165 }
5167 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
5168 * Illegal bytes are set one. */
5169 static const unsigned char utf8_bytes[256] = {
5170 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,
5171 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,
5172 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,
5173 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,
5174 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,
5175 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,
5176 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,
5177 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,
5178 };
5180 /* Decode UTF-8 multi-byte representation into a unicode character. */
5181 static inline unsigned long
5182 utf8_to_unicode(const char *string, size_t length)
5183 {
5184 unsigned long unicode;
5186 switch (length) {
5187 case 1:
5188 unicode = string[0];
5189 break;
5190 case 2:
5191 unicode = (string[0] & 0x1f) << 6;
5192 unicode += (string[1] & 0x3f);
5193 break;
5194 case 3:
5195 unicode = (string[0] & 0x0f) << 12;
5196 unicode += ((string[1] & 0x3f) << 6);
5197 unicode += (string[2] & 0x3f);
5198 break;
5199 case 4:
5200 unicode = (string[0] & 0x0f) << 18;
5201 unicode += ((string[1] & 0x3f) << 12);
5202 unicode += ((string[2] & 0x3f) << 6);
5203 unicode += (string[3] & 0x3f);
5204 break;
5205 case 5:
5206 unicode = (string[0] & 0x0f) << 24;
5207 unicode += ((string[1] & 0x3f) << 18);
5208 unicode += ((string[2] & 0x3f) << 12);
5209 unicode += ((string[3] & 0x3f) << 6);
5210 unicode += (string[4] & 0x3f);
5211 break;
5212 case 6:
5213 unicode = (string[0] & 0x01) << 30;
5214 unicode += ((string[1] & 0x3f) << 24);
5215 unicode += ((string[2] & 0x3f) << 18);
5216 unicode += ((string[3] & 0x3f) << 12);
5217 unicode += ((string[4] & 0x3f) << 6);
5218 unicode += (string[5] & 0x3f);
5219 break;
5220 default:
5221 die("Invalid unicode length");
5222 }
5224 /* Invalid characters could return the special 0xfffd value but NUL
5225 * should be just as good. */
5226 return unicode > 0xffff ? 0 : unicode;
5227 }
5229 /* Calculates how much of string can be shown within the given maximum width
5230 * and sets trimmed parameter to non-zero value if all of string could not be
5231 * shown. If the reserve flag is TRUE, it will reserve at least one
5232 * trailing character, which can be useful when drawing a delimiter.
5233 *
5234 * Returns the number of bytes to output from string to satisfy max_width. */
5235 static size_t
5236 utf8_length(const char *string, size_t max_width, int *trimmed, bool reserve)
5237 {
5238 const char *start = string;
5239 const char *end = strchr(string, '\0');
5240 unsigned char last_bytes = 0;
5241 size_t width = 0;
5243 *trimmed = 0;
5245 while (string < end) {
5246 int c = *(unsigned char *) string;
5247 unsigned char bytes = utf8_bytes[c];
5248 size_t ucwidth;
5249 unsigned long unicode;
5251 if (string + bytes > end)
5252 break;
5254 /* Change representation to figure out whether
5255 * it is a single- or double-width character. */
5257 unicode = utf8_to_unicode(string, bytes);
5258 /* FIXME: Graceful handling of invalid unicode character. */
5259 if (!unicode)
5260 break;
5262 ucwidth = unicode_width(unicode);
5263 width += ucwidth;
5264 if (width > max_width) {
5265 *trimmed = 1;
5266 if (reserve && width - ucwidth == max_width) {
5267 string -= last_bytes;
5268 }
5269 break;
5270 }
5272 string += bytes;
5273 last_bytes = bytes;
5274 }
5276 return string - start;
5277 }
5280 /*
5281 * Status management
5282 */
5284 /* Whether or not the curses interface has been initialized. */
5285 static bool cursed = FALSE;
5287 /* The status window is used for polling keystrokes. */
5288 static WINDOW *status_win;
5290 static bool status_empty = TRUE;
5292 /* Update status and title window. */
5293 static void
5294 report(const char *msg, ...)
5295 {
5296 struct view *view = display[current_view];
5298 if (input_mode)
5299 return;
5301 if (!view) {
5302 char buf[SIZEOF_STR];
5303 va_list args;
5305 va_start(args, msg);
5306 if (vsnprintf(buf, sizeof(buf), msg, args) >= sizeof(buf)) {
5307 buf[sizeof(buf) - 1] = 0;
5308 buf[sizeof(buf) - 2] = '.';
5309 buf[sizeof(buf) - 3] = '.';
5310 buf[sizeof(buf) - 4] = '.';
5311 }
5312 va_end(args);
5313 die("%s", buf);
5314 }
5316 if (!status_empty || *msg) {
5317 va_list args;
5319 va_start(args, msg);
5321 wmove(status_win, 0, 0);
5322 if (*msg) {
5323 vwprintw(status_win, msg, args);
5324 status_empty = FALSE;
5325 } else {
5326 status_empty = TRUE;
5327 }
5328 wclrtoeol(status_win);
5329 wrefresh(status_win);
5331 va_end(args);
5332 }
5334 update_view_title(view);
5335 update_display_cursor(view);
5336 }
5338 /* Controls when nodelay should be in effect when polling user input. */
5339 static void
5340 set_nonblocking_input(bool loading)
5341 {
5342 static unsigned int loading_views;
5344 if ((loading == FALSE && loading_views-- == 1) ||
5345 (loading == TRUE && loading_views++ == 0))
5346 nodelay(status_win, loading);
5347 }
5349 static void
5350 init_display(void)
5351 {
5352 int x, y;
5354 /* Initialize the curses library */
5355 if (isatty(STDIN_FILENO)) {
5356 cursed = !!initscr();
5357 } else {
5358 /* Leave stdin and stdout alone when acting as a pager. */
5359 FILE *io = fopen("/dev/tty", "r+");
5361 if (!io)
5362 die("Failed to open /dev/tty");
5363 cursed = !!newterm(NULL, io, io);
5364 }
5366 if (!cursed)
5367 die("Failed to initialize curses");
5369 nonl(); /* Tell curses not to do NL->CR/NL on output */
5370 cbreak(); /* Take input chars one at a time, no wait for \n */
5371 noecho(); /* Don't echo input */
5372 leaveok(stdscr, TRUE);
5374 if (has_colors())
5375 init_colors();
5377 getmaxyx(stdscr, y, x);
5378 status_win = newwin(1, 0, y - 1, 0);
5379 if (!status_win)
5380 die("Failed to create status window");
5382 /* Enable keyboard mapping */
5383 keypad(status_win, TRUE);
5384 wbkgdset(status_win, get_line_attr(LINE_STATUS));
5385 }
5387 static char *
5388 read_prompt(const char *prompt)
5389 {
5390 enum { READING, STOP, CANCEL } status = READING;
5391 static char buf[sizeof(opt_cmd) - STRING_SIZE("git \0")];
5392 int pos = 0;
5394 while (status == READING) {
5395 struct view *view;
5396 int i, key;
5398 input_mode = TRUE;
5400 foreach_view (view, i)
5401 update_view(view);
5403 input_mode = FALSE;
5405 mvwprintw(status_win, 0, 0, "%s%.*s", prompt, pos, buf);
5406 wclrtoeol(status_win);
5408 /* Refresh, accept single keystroke of input */
5409 key = wgetch(status_win);
5410 switch (key) {
5411 case KEY_RETURN:
5412 case KEY_ENTER:
5413 case '\n':
5414 status = pos ? STOP : CANCEL;
5415 break;
5417 case KEY_BACKSPACE:
5418 if (pos > 0)
5419 pos--;
5420 else
5421 status = CANCEL;
5422 break;
5424 case KEY_ESC:
5425 status = CANCEL;
5426 break;
5428 case ERR:
5429 break;
5431 default:
5432 if (pos >= sizeof(buf)) {
5433 report("Input string too long");
5434 return NULL;
5435 }
5437 if (isprint(key))
5438 buf[pos++] = (char) key;
5439 }
5440 }
5442 /* Clear the status window */
5443 status_empty = FALSE;
5444 report("");
5446 if (status == CANCEL)
5447 return NULL;
5449 buf[pos++] = 0;
5451 return buf;
5452 }
5454 /*
5455 * Repository references
5456 */
5458 static struct ref *refs = NULL;
5459 static size_t refs_alloc = 0;
5460 static size_t refs_size = 0;
5462 /* Id <-> ref store */
5463 static struct ref ***id_refs = NULL;
5464 static size_t id_refs_alloc = 0;
5465 static size_t id_refs_size = 0;
5467 static struct ref **
5468 get_refs(char *id)
5469 {
5470 struct ref ***tmp_id_refs;
5471 struct ref **ref_list = NULL;
5472 size_t ref_list_alloc = 0;
5473 size_t ref_list_size = 0;
5474 size_t i;
5476 for (i = 0; i < id_refs_size; i++)
5477 if (!strcmp(id, id_refs[i][0]->id))
5478 return id_refs[i];
5480 tmp_id_refs = realloc_items(id_refs, &id_refs_alloc, id_refs_size + 1,
5481 sizeof(*id_refs));
5482 if (!tmp_id_refs)
5483 return NULL;
5485 id_refs = tmp_id_refs;
5487 for (i = 0; i < refs_size; i++) {
5488 struct ref **tmp;
5490 if (strcmp(id, refs[i].id))
5491 continue;
5493 tmp = realloc_items(ref_list, &ref_list_alloc,
5494 ref_list_size + 1, sizeof(*ref_list));
5495 if (!tmp) {
5496 if (ref_list)
5497 free(ref_list);
5498 return NULL;
5499 }
5501 ref_list = tmp;
5502 if (ref_list_size > 0)
5503 ref_list[ref_list_size - 1]->next = 1;
5504 ref_list[ref_list_size] = &refs[i];
5506 /* XXX: The properties of the commit chains ensures that we can
5507 * safely modify the shared ref. The repo references will
5508 * always be similar for the same id. */
5509 ref_list[ref_list_size]->next = 0;
5510 ref_list_size++;
5511 }
5513 if (ref_list)
5514 id_refs[id_refs_size++] = ref_list;
5516 return ref_list;
5517 }
5519 static int
5520 read_ref(char *id, size_t idlen, char *name, size_t namelen)
5521 {
5522 struct ref *ref;
5523 bool tag = FALSE;
5524 bool ltag = FALSE;
5525 bool remote = FALSE;
5526 bool tracked = FALSE;
5527 bool check_replace = FALSE;
5528 bool head = FALSE;
5530 if (!strncmp(name, "refs/tags/", STRING_SIZE("refs/tags/"))) {
5531 if (!strcmp(name + namelen - 3, "^{}")) {
5532 namelen -= 3;
5533 name[namelen] = 0;
5534 if (refs_size > 0 && refs[refs_size - 1].ltag == TRUE)
5535 check_replace = TRUE;
5536 } else {
5537 ltag = TRUE;
5538 }
5540 tag = TRUE;
5541 namelen -= STRING_SIZE("refs/tags/");
5542 name += STRING_SIZE("refs/tags/");
5544 } else if (!strncmp(name, "refs/remotes/", STRING_SIZE("refs/remotes/"))) {
5545 remote = TRUE;
5546 namelen -= STRING_SIZE("refs/remotes/");
5547 name += STRING_SIZE("refs/remotes/");
5548 tracked = !strcmp(opt_remote, name);
5550 } else if (!strncmp(name, "refs/heads/", STRING_SIZE("refs/heads/"))) {
5551 namelen -= STRING_SIZE("refs/heads/");
5552 name += STRING_SIZE("refs/heads/");
5553 head = !strncmp(opt_head, name, namelen);
5555 } else if (!strcmp(name, "HEAD")) {
5556 opt_no_head = FALSE;
5557 return OK;
5558 }
5560 if (check_replace && !strcmp(name, refs[refs_size - 1].name)) {
5561 /* it's an annotated tag, replace the previous sha1 with the
5562 * resolved commit id; relies on the fact git-ls-remote lists
5563 * the commit id of an annotated tag right beofre the commit id
5564 * it points to. */
5565 refs[refs_size - 1].ltag = ltag;
5566 string_copy_rev(refs[refs_size - 1].id, id);
5568 return OK;
5569 }
5570 refs = realloc_items(refs, &refs_alloc, refs_size + 1, sizeof(*refs));
5571 if (!refs)
5572 return ERR;
5574 ref = &refs[refs_size++];
5575 ref->name = malloc(namelen + 1);
5576 if (!ref->name)
5577 return ERR;
5579 strncpy(ref->name, name, namelen);
5580 ref->name[namelen] = 0;
5581 ref->head = head;
5582 ref->tag = tag;
5583 ref->ltag = ltag;
5584 ref->remote = remote;
5585 ref->tracked = tracked;
5586 string_copy_rev(ref->id, id);
5588 return OK;
5589 }
5591 static int
5592 load_refs(void)
5593 {
5594 const char *cmd_env = getenv("TIG_LS_REMOTE");
5595 const char *cmd = cmd_env && *cmd_env ? cmd_env : TIG_LS_REMOTE;
5597 return read_properties(popen(cmd, "r"), "\t", read_ref);
5598 }
5600 static int
5601 read_repo_config_option(char *name, size_t namelen, char *value, size_t valuelen)
5602 {
5603 if (!strcmp(name, "i18n.commitencoding"))
5604 string_ncopy(opt_encoding, value, valuelen);
5606 if (!strcmp(name, "core.editor"))
5607 string_ncopy(opt_editor, value, valuelen);
5609 /* branch.<head>.remote */
5610 if (*opt_head &&
5611 !strncmp(name, "branch.", 7) &&
5612 !strncmp(name + 7, opt_head, strlen(opt_head)) &&
5613 !strcmp(name + 7 + strlen(opt_head), ".remote"))
5614 string_ncopy(opt_remote, value, valuelen);
5616 if (*opt_head && *opt_remote &&
5617 !strncmp(name, "branch.", 7) &&
5618 !strncmp(name + 7, opt_head, strlen(opt_head)) &&
5619 !strcmp(name + 7 + strlen(opt_head), ".merge")) {
5620 size_t from = strlen(opt_remote);
5622 if (!strncmp(value, "refs/heads/", STRING_SIZE("refs/heads/"))) {
5623 value += STRING_SIZE("refs/heads/");
5624 valuelen -= STRING_SIZE("refs/heads/");
5625 }
5627 if (!string_format_from(opt_remote, &from, "/%s", value))
5628 opt_remote[0] = 0;
5629 }
5631 return OK;
5632 }
5634 static int
5635 load_git_config(void)
5636 {
5637 return read_properties(popen(GIT_CONFIG " --list", "r"),
5638 "=", read_repo_config_option);
5639 }
5641 static int
5642 read_repo_info(char *name, size_t namelen, char *value, size_t valuelen)
5643 {
5644 if (!opt_git_dir[0]) {
5645 string_ncopy(opt_git_dir, name, namelen);
5647 } else if (opt_is_inside_work_tree == -1) {
5648 /* This can be 3 different values depending on the
5649 * version of git being used. If git-rev-parse does not
5650 * understand --is-inside-work-tree it will simply echo
5651 * the option else either "true" or "false" is printed.
5652 * Default to true for the unknown case. */
5653 opt_is_inside_work_tree = strcmp(name, "false") ? TRUE : FALSE;
5655 } else if (opt_cdup[0] == ' ') {
5656 string_ncopy(opt_cdup, name, namelen);
5657 } else {
5658 if (!strncmp(name, "refs/heads/", STRING_SIZE("refs/heads/"))) {
5659 namelen -= STRING_SIZE("refs/heads/");
5660 name += STRING_SIZE("refs/heads/");
5661 string_ncopy(opt_head, name, namelen);
5662 }
5663 }
5665 return OK;
5666 }
5668 static int
5669 load_repo_info(void)
5670 {
5671 int result;
5672 FILE *pipe = popen("(git rev-parse --git-dir --is-inside-work-tree "
5673 " --show-cdup; git symbolic-ref HEAD) 2>/dev/null", "r");
5675 /* XXX: The line outputted by "--show-cdup" can be empty so
5676 * initialize it to something invalid to make it possible to
5677 * detect whether it has been set or not. */
5678 opt_cdup[0] = ' ';
5680 result = read_properties(pipe, "=", read_repo_info);
5681 if (opt_cdup[0] == ' ')
5682 opt_cdup[0] = 0;
5684 return result;
5685 }
5687 static int
5688 read_properties(FILE *pipe, const char *separators,
5689 int (*read_property)(char *, size_t, char *, size_t))
5690 {
5691 char buffer[BUFSIZ];
5692 char *name;
5693 int state = OK;
5695 if (!pipe)
5696 return ERR;
5698 while (state == OK && (name = fgets(buffer, sizeof(buffer), pipe))) {
5699 char *value;
5700 size_t namelen;
5701 size_t valuelen;
5703 name = chomp_string(name);
5704 namelen = strcspn(name, separators);
5706 if (name[namelen]) {
5707 name[namelen] = 0;
5708 value = chomp_string(name + namelen + 1);
5709 valuelen = strlen(value);
5711 } else {
5712 value = "";
5713 valuelen = 0;
5714 }
5716 state = read_property(name, namelen, value, valuelen);
5717 }
5719 if (state != ERR && ferror(pipe))
5720 state = ERR;
5722 pclose(pipe);
5724 return state;
5725 }
5728 /*
5729 * Main
5730 */
5732 static void __NORETURN
5733 quit(int sig)
5734 {
5735 /* XXX: Restore tty modes and let the OS cleanup the rest! */
5736 if (cursed)
5737 endwin();
5738 exit(0);
5739 }
5741 static void __NORETURN
5742 die(const char *err, ...)
5743 {
5744 va_list args;
5746 endwin();
5748 va_start(args, err);
5749 fputs("tig: ", stderr);
5750 vfprintf(stderr, err, args);
5751 fputs("\n", stderr);
5752 va_end(args);
5754 exit(1);
5755 }
5757 static void
5758 warn(const char *msg, ...)
5759 {
5760 va_list args;
5762 va_start(args, msg);
5763 fputs("tig warning: ", stderr);
5764 vfprintf(stderr, msg, args);
5765 fputs("\n", stderr);
5766 va_end(args);
5767 }
5769 int
5770 main(int argc, char *argv[])
5771 {
5772 struct view *view;
5773 enum request request;
5774 size_t i;
5776 signal(SIGINT, quit);
5778 if (setlocale(LC_ALL, "")) {
5779 char *codeset = nl_langinfo(CODESET);
5781 string_ncopy(opt_codeset, codeset, strlen(codeset));
5782 }
5784 if (load_repo_info() == ERR)
5785 die("Failed to load repo info.");
5787 if (load_options() == ERR)
5788 die("Failed to load user config.");
5790 if (load_git_config() == ERR)
5791 die("Failed to load repo config.");
5793 if (!parse_options(argc, argv))
5794 return 0;
5796 /* Require a git repository unless when running in pager mode. */
5797 if (!opt_git_dir[0] && opt_request != REQ_VIEW_PAGER)
5798 die("Not a git repository");
5800 if (*opt_encoding && strcasecmp(opt_encoding, "UTF-8"))
5801 opt_utf8 = FALSE;
5803 if (*opt_codeset && strcmp(opt_codeset, opt_encoding)) {
5804 opt_iconv = iconv_open(opt_codeset, opt_encoding);
5805 if (opt_iconv == ICONV_NONE)
5806 die("Failed to initialize character set conversion");
5807 }
5809 if (*opt_git_dir && load_refs() == ERR)
5810 die("Failed to load refs.");
5812 for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
5813 view->cmd_env = getenv(view->cmd_env);
5815 request = opt_request;
5817 init_display();
5819 while (view_driver(display[current_view], request)) {
5820 int key;
5821 int i;
5823 foreach_view (view, i)
5824 update_view(view);
5826 /* Refresh, accept single keystroke of input */
5827 key = wgetch(status_win);
5829 /* wgetch() with nodelay() enabled returns ERR when there's no
5830 * input. */
5831 if (key == ERR) {
5832 request = REQ_NONE;
5833 continue;
5834 }
5836 request = get_keybinding(display[current_view]->keymap, key);
5838 /* Some low-level request handling. This keeps access to
5839 * status_win restricted. */
5840 switch (request) {
5841 case REQ_PROMPT:
5842 {
5843 char *cmd = read_prompt(":");
5845 if (cmd && string_format(opt_cmd, "git %s", cmd)) {
5846 if (strncmp(cmd, "show", 4) && isspace(cmd[4])) {
5847 opt_request = REQ_VIEW_DIFF;
5848 } else {
5849 opt_request = REQ_VIEW_PAGER;
5850 }
5851 break;
5852 }
5854 request = REQ_NONE;
5855 break;
5856 }
5857 case REQ_SEARCH:
5858 case REQ_SEARCH_BACK:
5859 {
5860 const char *prompt = request == REQ_SEARCH
5861 ? "/" : "?";
5862 char *search = read_prompt(prompt);
5864 if (search)
5865 string_ncopy(opt_search, search, strlen(search));
5866 else
5867 request = REQ_NONE;
5868 break;
5869 }
5870 case REQ_SCREEN_RESIZE:
5871 {
5872 int height, width;
5874 getmaxyx(stdscr, height, width);
5876 /* Resize the status view and let the view driver take
5877 * care of resizing the displayed views. */
5878 wresize(status_win, 1, width);
5879 mvwin(status_win, height - 1, 0);
5880 wrefresh(status_win);
5881 break;
5882 }
5883 default:
5884 break;
5885 }
5886 }
5888 quit(0);
5890 return 0;
5891 }