Code

27563e19670e252a8bf90b85416a30d8a15cdb12
[tig.git] / tig.c
1 /* Copyright (c) 2006-2009 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/wait.h>
36 #include <sys/stat.h>
37 #include <sys/select.h>
38 #include <unistd.h>
39 #include <time.h>
40 #include <fcntl.h>
42 #include <regex.h>
44 #include <locale.h>
45 #include <langinfo.h>
46 #include <iconv.h>
48 /* ncurses(3): Must be defined to have extended wide-character functions. */
49 #define _XOPEN_SOURCE_EXTENDED
51 #ifdef HAVE_NCURSESW_NCURSES_H
52 #include <ncursesw/ncurses.h>
53 #else
54 #ifdef HAVE_NCURSES_NCURSES_H
55 #include <ncurses/ncurses.h>
56 #else
57 #include <ncurses.h>
58 #endif
59 #endif
61 #if __GNUC__ >= 3
62 #define __NORETURN __attribute__((__noreturn__))
63 #else
64 #define __NORETURN
65 #endif
67 static void __NORETURN die(const char *err, ...);
68 static void warn(const char *msg, ...);
69 static void report(const char *msg, ...);
70 static void set_nonblocking_input(bool loading);
71 static int load_refs(void);
72 static size_t utf8_length(const char **string, size_t col, int *width, size_t max_width, int *trimmed, bool reserve);
74 #define ABS(x)          ((x) >= 0  ? (x) : -(x))
75 #define MIN(x, y)       ((x) < (y) ? (x) :  (y))
77 #define ARRAY_SIZE(x)   (sizeof(x) / sizeof(x[0]))
78 #define STRING_SIZE(x)  (sizeof(x) - 1)
80 #define SIZEOF_STR      1024    /* Default string size. */
81 #define SIZEOF_REF      256     /* Size of symbolic or SHA1 ID. */
82 #define SIZEOF_REV      41      /* Holds a SHA-1 and an ending NUL. */
83 #define SIZEOF_ARG      32      /* Default argument array size. */
85 /* Revision graph */
87 #define REVGRAPH_INIT   'I'
88 #define REVGRAPH_MERGE  'M'
89 #define REVGRAPH_BRANCH '+'
90 #define REVGRAPH_COMMIT '*'
91 #define REVGRAPH_BOUND  '^'
93 #define SIZEOF_REVGRAPH 19      /* Size of revision ancestry graphics. */
95 /* This color name can be used to refer to the default term colors. */
96 #define COLOR_DEFAULT   (-1)
98 #define ICONV_NONE      ((iconv_t) -1)
99 #ifndef ICONV_CONST
100 #define ICONV_CONST     /* nothing */
101 #endif
103 /* The format and size of the date column in the main view. */
104 #define DATE_FORMAT     "%Y-%m-%d %H:%M"
105 #define DATE_COLS       STRING_SIZE("2006-04-29 14:21 ")
107 #define AUTHOR_COLS     20
108 #define ID_COLS         8
110 /* The default interval between line numbers. */
111 #define NUMBER_INTERVAL 5
112 #define SCROLL_INTERVAL 1
114 #define TAB_SIZE        8
116 #define SCALE_SPLIT_VIEW(height)        ((height) * 2 / 3)
118 #define NULL_ID         "0000000000000000000000000000000000000000"
120 #ifndef GIT_CONFIG
121 #define GIT_CONFIG "config"
122 #endif
124 /* Some ascii-shorthands fitted into the ncurses namespace. */
125 #define KEY_TAB         '\t'
126 #define KEY_RETURN      '\r'
127 #define KEY_ESC         27
130 struct ref {
131         char *name;             /* Ref name; tag or head names are shortened. */
132         char id[SIZEOF_REV];    /* Commit SHA1 ID */
133         unsigned int head:1;    /* Is it the current HEAD? */
134         unsigned int tag:1;     /* Is it a tag? */
135         unsigned int ltag:1;    /* If so, is the tag local? */
136         unsigned int remote:1;  /* Is it a remote ref? */
137         unsigned int tracked:1; /* Is it the remote for the current HEAD? */
138         unsigned int next:1;    /* For ref lists: are there more refs? */
139 };
141 static struct ref **get_refs(const char *id);
143 enum format_flags {
144         FORMAT_ALL,             /* Perform replacement in all arguments. */
145         FORMAT_DASH,            /* Perform replacement up until "--". */
146         FORMAT_NONE             /* No replacement should be performed. */
147 };
149 static bool format_argv(const char *dst[], const char *src[], enum format_flags flags);
151 struct int_map {
152         const char *name;
153         int namelen;
154         int value;
155 };
157 static int
158 set_from_int_map(struct int_map *map, size_t map_size,
159                  int *value, const char *name, int namelen)
162         int i;
164         for (i = 0; i < map_size; i++)
165                 if (namelen == map[i].namelen &&
166                     !strncasecmp(name, map[i].name, namelen)) {
167                         *value = map[i].value;
168                         return OK;
169                 }
171         return ERR;
174 enum input_status {
175         INPUT_OK,
176         INPUT_SKIP,
177         INPUT_STOP,
178         INPUT_CANCEL
179 };
181 typedef enum input_status (*input_handler)(void *data, char *buf, int c);
183 static char *prompt_input(const char *prompt, input_handler handler, void *data);
184 static bool prompt_yesno(const char *prompt);
186 /*
187  * String helpers
188  */
190 static inline void
191 string_ncopy_do(char *dst, size_t dstlen, const char *src, size_t srclen)
193         if (srclen > dstlen - 1)
194                 srclen = dstlen - 1;
196         strncpy(dst, src, srclen);
197         dst[srclen] = 0;
200 /* Shorthands for safely copying into a fixed buffer. */
202 #define string_copy(dst, src) \
203         string_ncopy_do(dst, sizeof(dst), src, sizeof(src))
205 #define string_ncopy(dst, src, srclen) \
206         string_ncopy_do(dst, sizeof(dst), src, srclen)
208 #define string_copy_rev(dst, src) \
209         string_ncopy_do(dst, SIZEOF_REV, src, SIZEOF_REV - 1)
211 #define string_add(dst, from, src) \
212         string_ncopy_do(dst + (from), sizeof(dst) - (from), src, sizeof(src))
214 static size_t
215 string_expand_length(const char *line, int tabsize)
217         size_t size, pos;
219         for (pos = 0; line[pos]; pos++) {
220                 if (line[pos] == '\t' && tabsize > 0)
221                         size += tabsize - (size % tabsize);
222                 else
223                         size++;
224         }
225         return size;
228 static void
229 string_expand(char *dst, size_t dstlen, const char *src, int tabsize)
231         size_t size, pos;
233         for (size = pos = 0; size < dstlen - 1 && src[pos]; pos++) {
234                 if (src[pos] == '\t') {
235                         size_t expanded = tabsize - (size % tabsize);
237                         if (expanded + size >= dstlen - 1)
238                                 expanded = dstlen - size - 1;
239                         memcpy(dst + size, "        ", expanded);
240                         size += expanded;
241                 } else {
242                         dst[size++] = src[pos];
243                 }
244         }
246         dst[size] = 0;
249 static char *
250 chomp_string(char *name)
252         int namelen;
254         while (isspace(*name))
255                 name++;
257         namelen = strlen(name) - 1;
258         while (namelen > 0 && isspace(name[namelen]))
259                 name[namelen--] = 0;
261         return name;
264 static bool
265 string_nformat(char *buf, size_t bufsize, size_t *bufpos, const char *fmt, ...)
267         va_list args;
268         size_t pos = bufpos ? *bufpos : 0;
270         va_start(args, fmt);
271         pos += vsnprintf(buf + pos, bufsize - pos, fmt, args);
272         va_end(args);
274         if (bufpos)
275                 *bufpos = pos;
277         return pos >= bufsize ? FALSE : TRUE;
280 #define string_format(buf, fmt, args...) \
281         string_nformat(buf, sizeof(buf), NULL, fmt, args)
283 #define string_format_from(buf, from, fmt, args...) \
284         string_nformat(buf, sizeof(buf), from, fmt, args)
286 static int
287 string_enum_compare(const char *str1, const char *str2, int len)
289         size_t i;
291 #define string_enum_sep(x) ((x) == '-' || (x) == '_' || (x) == '.')
293         /* Diff-Header == DIFF_HEADER */
294         for (i = 0; i < len; i++) {
295                 if (toupper(str1[i]) == toupper(str2[i]))
296                         continue;
298                 if (string_enum_sep(str1[i]) &&
299                     string_enum_sep(str2[i]))
300                         continue;
302                 return str1[i] - str2[i];
303         }
305         return 0;
308 #define prefixcmp(str1, str2) \
309         strncmp(str1, str2, STRING_SIZE(str2))
311 static inline int
312 suffixcmp(const char *str, int slen, const char *suffix)
314         size_t len = slen >= 0 ? slen : strlen(str);
315         size_t suffixlen = strlen(suffix);
317         return suffixlen < len ? strcmp(str + len - suffixlen, suffix) : -1;
321 static bool
322 argv_from_string(const char *argv[SIZEOF_ARG], int *argc, char *cmd)
324         int valuelen;
326         while (*cmd && *argc < SIZEOF_ARG && (valuelen = strcspn(cmd, " \t"))) {
327                 bool advance = cmd[valuelen] != 0;
329                 cmd[valuelen] = 0;
330                 argv[(*argc)++] = chomp_string(cmd);
331                 cmd = chomp_string(cmd + valuelen + advance);
332         }
334         if (*argc < SIZEOF_ARG)
335                 argv[*argc] = NULL;
336         return *argc < SIZEOF_ARG;
339 static void
340 argv_from_env(const char **argv, const char *name)
342         char *env = argv ? getenv(name) : NULL;
343         int argc = 0;
345         if (env && *env)
346                 env = strdup(env);
347         if (env && !argv_from_string(argv, &argc, env))
348                 die("Too many arguments in the `%s` environment variable", name);
352 /*
353  * Executing external commands.
354  */
356 enum io_type {
357         IO_FD,                  /* File descriptor based IO. */
358         IO_BG,                  /* Execute command in the background. */
359         IO_FG,                  /* Execute command with same std{in,out,err}. */
360         IO_RD,                  /* Read only fork+exec IO. */
361         IO_WR,                  /* Write only fork+exec IO. */
362         IO_AP,                  /* Append fork+exec output to file. */
363 };
365 struct io {
366         enum io_type type;      /* The requested type of pipe. */
367         const char *dir;        /* Directory from which to execute. */
368         pid_t pid;              /* Pipe for reading or writing. */
369         int pipe;               /* Pipe end for reading or writing. */
370         int error;              /* Error status. */
371         const char *argv[SIZEOF_ARG];   /* Shell command arguments. */
372         char *buf;              /* Read buffer. */
373         size_t bufalloc;        /* Allocated buffer size. */
374         size_t bufsize;         /* Buffer content size. */
375         char *bufpos;           /* Current buffer position. */
376         unsigned int eof:1;     /* Has end of file been reached. */
377 };
379 static void
380 reset_io(struct io *io)
382         io->pipe = -1;
383         io->pid = 0;
384         io->buf = io->bufpos = NULL;
385         io->bufalloc = io->bufsize = 0;
386         io->error = 0;
387         io->eof = 0;
390 static void
391 init_io(struct io *io, const char *dir, enum io_type type)
393         reset_io(io);
394         io->type = type;
395         io->dir = dir;
398 static bool
399 init_io_rd(struct io *io, const char *argv[], const char *dir,
400                 enum format_flags flags)
402         init_io(io, dir, IO_RD);
403         return format_argv(io->argv, argv, flags);
406 static bool
407 io_open(struct io *io, const char *name)
409         init_io(io, NULL, IO_FD);
410         io->pipe = *name ? open(name, O_RDONLY) : STDIN_FILENO;
411         return io->pipe != -1;
414 static bool
415 kill_io(struct io *io)
417         return io->pid == 0 || kill(io->pid, SIGKILL) != -1;
420 static bool
421 done_io(struct io *io)
423         pid_t pid = io->pid;
425         if (io->pipe != -1)
426                 close(io->pipe);
427         free(io->buf);
428         reset_io(io);
430         while (pid > 0) {
431                 int status;
432                 pid_t waiting = waitpid(pid, &status, 0);
434                 if (waiting < 0) {
435                         if (errno == EINTR)
436                                 continue;
437                         report("waitpid failed (%s)", strerror(errno));
438                         return FALSE;
439                 }
441                 return waiting == pid &&
442                        !WIFSIGNALED(status) &&
443                        WIFEXITED(status) &&
444                        !WEXITSTATUS(status);
445         }
447         return TRUE;
450 static bool
451 start_io(struct io *io)
453         int pipefds[2] = { -1, -1 };
455         if (io->type == IO_FD)
456                 return TRUE;
458         if ((io->type == IO_RD || io->type == IO_WR) &&
459             pipe(pipefds) < 0)
460                 return FALSE;
461         else if (io->type == IO_AP)
462                 pipefds[1] = io->pipe;
464         if ((io->pid = fork())) {
465                 if (pipefds[!(io->type == IO_WR)] != -1)
466                         close(pipefds[!(io->type == IO_WR)]);
467                 if (io->pid != -1) {
468                         io->pipe = pipefds[!!(io->type == IO_WR)];
469                         return TRUE;
470                 }
472         } else {
473                 if (io->type != IO_FG) {
474                         int devnull = open("/dev/null", O_RDWR);
475                         int readfd  = io->type == IO_WR ? pipefds[0] : devnull;
476                         int writefd = (io->type == IO_RD || io->type == IO_AP)
477                                                         ? pipefds[1] : devnull;
479                         dup2(readfd,  STDIN_FILENO);
480                         dup2(writefd, STDOUT_FILENO);
481                         dup2(devnull, STDERR_FILENO);
483                         close(devnull);
484                         if (pipefds[0] != -1)
485                                 close(pipefds[0]);
486                         if (pipefds[1] != -1)
487                                 close(pipefds[1]);
488                 }
490                 if (io->dir && *io->dir && chdir(io->dir) == -1)
491                         die("Failed to change directory: %s", strerror(errno));
493                 execvp(io->argv[0], (char *const*) io->argv);
494                 die("Failed to execute program: %s", strerror(errno));
495         }
497         if (pipefds[!!(io->type == IO_WR)] != -1)
498                 close(pipefds[!!(io->type == IO_WR)]);
499         return FALSE;
502 static bool
503 run_io(struct io *io, const char **argv, const char *dir, enum io_type type)
505         init_io(io, dir, type);
506         if (!format_argv(io->argv, argv, FORMAT_NONE))
507                 return FALSE;
508         return start_io(io);
511 static int
512 run_io_do(struct io *io)
514         return start_io(io) && done_io(io);
517 static int
518 run_io_bg(const char **argv)
520         struct io io = {};
522         init_io(&io, NULL, IO_BG);
523         if (!format_argv(io.argv, argv, FORMAT_NONE))
524                 return FALSE;
525         return run_io_do(&io);
528 static bool
529 run_io_fg(const char **argv, const char *dir)
531         struct io io = {};
533         init_io(&io, dir, IO_FG);
534         if (!format_argv(io.argv, argv, FORMAT_NONE))
535                 return FALSE;
536         return run_io_do(&io);
539 static bool
540 run_io_append(const char **argv, enum format_flags flags, int fd)
542         struct io io = {};
544         init_io(&io, NULL, IO_AP);
545         io.pipe = fd;
546         if (format_argv(io.argv, argv, flags))
547                 return run_io_do(&io);
548         close(fd);
549         return FALSE;
552 static bool
553 run_io_rd(struct io *io, const char **argv, enum format_flags flags)
555         return init_io_rd(io, argv, NULL, flags) && start_io(io);
558 static bool
559 io_eof(struct io *io)
561         return io->eof;
564 static int
565 io_error(struct io *io)
567         return io->error;
570 static bool
571 io_strerror(struct io *io)
573         return strerror(io->error);
576 static bool
577 io_can_read(struct io *io)
579         struct timeval tv = { 0, 500 };
580         fd_set fds;
582         FD_ZERO(&fds);
583         FD_SET(io->pipe, &fds);
585         return select(io->pipe + 1, &fds, NULL, NULL, &tv) > 0;
588 static ssize_t
589 io_read(struct io *io, void *buf, size_t bufsize)
591         do {
592                 ssize_t readsize = read(io->pipe, buf, bufsize);
594                 if (readsize < 0 && (errno == EAGAIN || errno == EINTR))
595                         continue;
596                 else if (readsize == -1)
597                         io->error = errno;
598                 else if (readsize == 0)
599                         io->eof = 1;
600                 return readsize;
601         } while (1);
604 static char *
605 io_get(struct io *io, int c, bool can_read)
607         char *eol;
608         ssize_t readsize;
610         if (!io->buf) {
611                 io->buf = io->bufpos = malloc(BUFSIZ);
612                 if (!io->buf)
613                         return NULL;
614                 io->bufalloc = BUFSIZ;
615                 io->bufsize = 0;
616         }
618         while (TRUE) {
619                 if (io->bufsize > 0) {
620                         eol = memchr(io->bufpos, c, io->bufsize);
621                         if (eol) {
622                                 char *line = io->bufpos;
624                                 *eol = 0;
625                                 io->bufpos = eol + 1;
626                                 io->bufsize -= io->bufpos - line;
627                                 return line;
628                         }
629                 }
631                 if (io_eof(io)) {
632                         if (io->bufsize) {
633                                 io->bufpos[io->bufsize] = 0;
634                                 io->bufsize = 0;
635                                 return io->bufpos;
636                         }
637                         return NULL;
638                 }
640                 if (!can_read)
641                         return NULL;
643                 if (io->bufsize > 0 && io->bufpos > io->buf)
644                         memmove(io->buf, io->bufpos, io->bufsize);
646                 io->bufpos = io->buf;
647                 readsize = io_read(io, io->buf + io->bufsize, io->bufalloc - io->bufsize);
648                 if (io_error(io))
649                         return NULL;
650                 io->bufsize += readsize;
651         }
654 static bool
655 io_write(struct io *io, const void *buf, size_t bufsize)
657         size_t written = 0;
659         while (!io_error(io) && written < bufsize) {
660                 ssize_t size;
662                 size = write(io->pipe, buf + written, bufsize - written);
663                 if (size < 0 && (errno == EAGAIN || errno == EINTR))
664                         continue;
665                 else if (size == -1)
666                         io->error = errno;
667                 else
668                         written += size;
669         }
671         return written == bufsize;
674 static bool
675 run_io_buf(const char **argv, char buf[], size_t bufsize)
677         struct io io = {};
678         bool error;
680         if (!run_io_rd(&io, argv, FORMAT_NONE))
681                 return FALSE;
683         io.buf = io.bufpos = buf;
684         io.bufalloc = bufsize;
685         error = !io_get(&io, '\n', TRUE) && io_error(&io);
686         io.buf = NULL;
688         return done_io(&io) || error;
691 static int
692 io_load(struct io *io, const char *separators,
693         int (*read_property)(char *, size_t, char *, size_t))
695         char *name;
696         int state = OK;
698         if (!start_io(io))
699                 return ERR;
701         while (state == OK && (name = io_get(io, '\n', TRUE))) {
702                 char *value;
703                 size_t namelen;
704                 size_t valuelen;
706                 name = chomp_string(name);
707                 namelen = strcspn(name, separators);
709                 if (name[namelen]) {
710                         name[namelen] = 0;
711                         value = chomp_string(name + namelen + 1);
712                         valuelen = strlen(value);
714                 } else {
715                         value = "";
716                         valuelen = 0;
717                 }
719                 state = read_property(name, namelen, value, valuelen);
720         }
722         if (state != ERR && io_error(io))
723                 state = ERR;
724         done_io(io);
726         return state;
729 static int
730 run_io_load(const char **argv, const char *separators,
731             int (*read_property)(char *, size_t, char *, size_t))
733         struct io io = {};
735         return init_io_rd(&io, argv, NULL, FORMAT_NONE)
736                 ? io_load(&io, separators, read_property) : ERR;
740 /*
741  * User requests
742  */
744 #define REQ_INFO \
745         /* XXX: Keep the view request first and in sync with views[]. */ \
746         REQ_GROUP("View switching") \
747         REQ_(VIEW_MAIN,         "Show main view"), \
748         REQ_(VIEW_DIFF,         "Show diff view"), \
749         REQ_(VIEW_LOG,          "Show log view"), \
750         REQ_(VIEW_TREE,         "Show tree view"), \
751         REQ_(VIEW_BLOB,         "Show blob view"), \
752         REQ_(VIEW_BLAME,        "Show blame view"), \
753         REQ_(VIEW_HELP,         "Show help page"), \
754         REQ_(VIEW_PAGER,        "Show pager view"), \
755         REQ_(VIEW_STATUS,       "Show status view"), \
756         REQ_(VIEW_STAGE,        "Show stage view"), \
757         \
758         REQ_GROUP("View manipulation") \
759         REQ_(ENTER,             "Enter current line and scroll"), \
760         REQ_(NEXT,              "Move to next"), \
761         REQ_(PREVIOUS,          "Move to previous"), \
762         REQ_(PARENT,            "Move to parent"), \
763         REQ_(VIEW_NEXT,         "Move focus to next view"), \
764         REQ_(REFRESH,           "Reload and refresh"), \
765         REQ_(MAXIMIZE,          "Maximize the current view"), \
766         REQ_(VIEW_CLOSE,        "Close the current view"), \
767         REQ_(QUIT,              "Close all views and quit"), \
768         \
769         REQ_GROUP("View specific requests") \
770         REQ_(STATUS_UPDATE,     "Update file status"), \
771         REQ_(STATUS_REVERT,     "Revert file changes"), \
772         REQ_(STATUS_MERGE,      "Merge file using external tool"), \
773         REQ_(STAGE_NEXT,        "Find next chunk to stage"), \
774         \
775         REQ_GROUP("Cursor navigation") \
776         REQ_(MOVE_UP,           "Move cursor one line up"), \
777         REQ_(MOVE_DOWN,         "Move cursor one line down"), \
778         REQ_(MOVE_PAGE_DOWN,    "Move cursor one page down"), \
779         REQ_(MOVE_PAGE_UP,      "Move cursor one page up"), \
780         REQ_(MOVE_FIRST_LINE,   "Move cursor to first line"), \
781         REQ_(MOVE_LAST_LINE,    "Move cursor to last line"), \
782         \
783         REQ_GROUP("Scrolling") \
784         REQ_(SCROLL_LEFT,       "Scroll two columns left"), \
785         REQ_(SCROLL_RIGHT,      "Scroll two columns right"), \
786         REQ_(SCROLL_LINE_UP,    "Scroll one line up"), \
787         REQ_(SCROLL_LINE_DOWN,  "Scroll one line down"), \
788         REQ_(SCROLL_PAGE_UP,    "Scroll one page up"), \
789         REQ_(SCROLL_PAGE_DOWN,  "Scroll one page down"), \
790         \
791         REQ_GROUP("Searching") \
792         REQ_(SEARCH,            "Search the view"), \
793         REQ_(SEARCH_BACK,       "Search backwards in the view"), \
794         REQ_(FIND_NEXT,         "Find next search match"), \
795         REQ_(FIND_PREV,         "Find previous search match"), \
796         \
797         REQ_GROUP("Option manipulation") \
798         REQ_(TOGGLE_LINENO,     "Toggle line numbers"), \
799         REQ_(TOGGLE_DATE,       "Toggle date display"), \
800         REQ_(TOGGLE_AUTHOR,     "Toggle author display"), \
801         REQ_(TOGGLE_REV_GRAPH,  "Toggle revision graph visualization"), \
802         REQ_(TOGGLE_REFS,       "Toggle reference display (tags/branches)"), \
803         \
804         REQ_GROUP("Misc") \
805         REQ_(PROMPT,            "Bring up the prompt"), \
806         REQ_(SCREEN_REDRAW,     "Redraw the screen"), \
807         REQ_(SHOW_VERSION,      "Show version information"), \
808         REQ_(STOP_LOADING,      "Stop all loading views"), \
809         REQ_(EDIT,              "Open in editor"), \
810         REQ_(NONE,              "Do nothing")
813 /* User action requests. */
814 enum request {
815 #define REQ_GROUP(help)
816 #define REQ_(req, help) REQ_##req
818         /* Offset all requests to avoid conflicts with ncurses getch values. */
819         REQ_OFFSET = KEY_MAX + 1,
820         REQ_INFO
822 #undef  REQ_GROUP
823 #undef  REQ_
824 };
826 struct request_info {
827         enum request request;
828         const char *name;
829         int namelen;
830         const char *help;
831 };
833 static struct request_info req_info[] = {
834 #define REQ_GROUP(help) { 0, NULL, 0, (help) },
835 #define REQ_(req, help) { REQ_##req, (#req), STRING_SIZE(#req), (help) }
836         REQ_INFO
837 #undef  REQ_GROUP
838 #undef  REQ_
839 };
841 static enum request
842 get_request(const char *name)
844         int namelen = strlen(name);
845         int i;
847         for (i = 0; i < ARRAY_SIZE(req_info); i++)
848                 if (req_info[i].namelen == namelen &&
849                     !string_enum_compare(req_info[i].name, name, namelen))
850                         return req_info[i].request;
852         return REQ_NONE;
856 /*
857  * Options
858  */
860 static const char usage[] =
861 "tig " TIG_VERSION " (" __DATE__ ")\n"
862 "\n"
863 "Usage: tig        [options] [revs] [--] [paths]\n"
864 "   or: tig show   [options] [revs] [--] [paths]\n"
865 "   or: tig blame  [rev] path\n"
866 "   or: tig status\n"
867 "   or: tig <      [git command output]\n"
868 "\n"
869 "Options:\n"
870 "  -v, --version   Show version and exit\n"
871 "  -h, --help      Show help message and exit";
873 /* Option and state variables. */
874 static bool opt_date                    = TRUE;
875 static bool opt_author                  = TRUE;
876 static bool opt_line_number             = FALSE;
877 static bool opt_line_graphics           = TRUE;
878 static bool opt_rev_graph               = FALSE;
879 static bool opt_show_refs               = TRUE;
880 static int opt_num_interval             = NUMBER_INTERVAL;
881 static int opt_tab_size                 = TAB_SIZE;
882 static int opt_author_cols              = AUTHOR_COLS-1;
883 static char opt_path[SIZEOF_STR]        = "";
884 static char opt_file[SIZEOF_STR]        = "";
885 static char opt_ref[SIZEOF_REF]         = "";
886 static char opt_head[SIZEOF_REF]        = "";
887 static char opt_head_rev[SIZEOF_REV]    = "";
888 static char opt_remote[SIZEOF_REF]      = "";
889 static char opt_encoding[20]            = "UTF-8";
890 static bool opt_utf8                    = TRUE;
891 static char opt_codeset[20]             = "UTF-8";
892 static iconv_t opt_iconv                = ICONV_NONE;
893 static char opt_search[SIZEOF_STR]      = "";
894 static char opt_cdup[SIZEOF_STR]        = "";
895 static char opt_prefix[SIZEOF_STR]      = "";
896 static char opt_git_dir[SIZEOF_STR]     = "";
897 static signed char opt_is_inside_work_tree      = -1; /* set to TRUE or FALSE */
898 static char opt_editor[SIZEOF_STR]      = "";
899 static FILE *opt_tty                    = NULL;
901 #define is_initial_commit()     (!*opt_head_rev)
902 #define is_head_commit(rev)     (!strcmp((rev), "HEAD") || !strcmp(opt_head_rev, (rev)))
905 /*
906  * Line-oriented content detection.
907  */
909 #define LINE_INFO \
910 LINE(DIFF_HEADER,  "diff --git ",       COLOR_YELLOW,   COLOR_DEFAULT,  0), \
911 LINE(DIFF_CHUNK,   "@@",                COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
912 LINE(DIFF_ADD,     "+",                 COLOR_GREEN,    COLOR_DEFAULT,  0), \
913 LINE(DIFF_DEL,     "-",                 COLOR_RED,      COLOR_DEFAULT,  0), \
914 LINE(DIFF_INDEX,        "index ",         COLOR_BLUE,   COLOR_DEFAULT,  0), \
915 LINE(DIFF_OLDMODE,      "old file mode ", COLOR_YELLOW, COLOR_DEFAULT,  0), \
916 LINE(DIFF_NEWMODE,      "new file mode ", COLOR_YELLOW, COLOR_DEFAULT,  0), \
917 LINE(DIFF_COPY_FROM,    "copy from",      COLOR_YELLOW, COLOR_DEFAULT,  0), \
918 LINE(DIFF_COPY_TO,      "copy to",        COLOR_YELLOW, COLOR_DEFAULT,  0), \
919 LINE(DIFF_RENAME_FROM,  "rename from",    COLOR_YELLOW, COLOR_DEFAULT,  0), \
920 LINE(DIFF_RENAME_TO,    "rename to",      COLOR_YELLOW, COLOR_DEFAULT,  0), \
921 LINE(DIFF_SIMILARITY,   "similarity ",    COLOR_YELLOW, COLOR_DEFAULT,  0), \
922 LINE(DIFF_DISSIMILARITY,"dissimilarity ", COLOR_YELLOW, COLOR_DEFAULT,  0), \
923 LINE(DIFF_TREE,         "diff-tree ",     COLOR_BLUE,   COLOR_DEFAULT,  0), \
924 LINE(PP_AUTHOR,    "Author: ",          COLOR_CYAN,     COLOR_DEFAULT,  0), \
925 LINE(PP_COMMIT,    "Commit: ",          COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
926 LINE(PP_MERGE,     "Merge: ",           COLOR_BLUE,     COLOR_DEFAULT,  0), \
927 LINE(PP_DATE,      "Date:   ",          COLOR_YELLOW,   COLOR_DEFAULT,  0), \
928 LINE(PP_ADATE,     "AuthorDate: ",      COLOR_YELLOW,   COLOR_DEFAULT,  0), \
929 LINE(PP_CDATE,     "CommitDate: ",      COLOR_YELLOW,   COLOR_DEFAULT,  0), \
930 LINE(PP_REFS,      "Refs: ",            COLOR_RED,      COLOR_DEFAULT,  0), \
931 LINE(COMMIT,       "commit ",           COLOR_GREEN,    COLOR_DEFAULT,  0), \
932 LINE(PARENT,       "parent ",           COLOR_BLUE,     COLOR_DEFAULT,  0), \
933 LINE(TREE,         "tree ",             COLOR_BLUE,     COLOR_DEFAULT,  0), \
934 LINE(AUTHOR,       "author ",           COLOR_CYAN,     COLOR_DEFAULT,  0), \
935 LINE(COMMITTER,    "committer ",        COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
936 LINE(SIGNOFF,      "    Signed-off-by", COLOR_YELLOW,   COLOR_DEFAULT,  0), \
937 LINE(ACKED,        "    Acked-by",      COLOR_YELLOW,   COLOR_DEFAULT,  0), \
938 LINE(DEFAULT,      "",                  COLOR_DEFAULT,  COLOR_DEFAULT,  A_NORMAL), \
939 LINE(CURSOR,       "",                  COLOR_WHITE,    COLOR_GREEN,    A_BOLD), \
940 LINE(STATUS,       "",                  COLOR_GREEN,    COLOR_DEFAULT,  0), \
941 LINE(DELIMITER,    "",                  COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
942 LINE(DATE,         "",                  COLOR_BLUE,     COLOR_DEFAULT,  0), \
943 LINE(LINE_NUMBER,  "",                  COLOR_CYAN,     COLOR_DEFAULT,  0), \
944 LINE(TITLE_BLUR,   "",                  COLOR_WHITE,    COLOR_BLUE,     0), \
945 LINE(TITLE_FOCUS,  "",                  COLOR_WHITE,    COLOR_BLUE,     A_BOLD), \
946 LINE(MAIN_AUTHOR,  "",                  COLOR_GREEN,    COLOR_DEFAULT,  0), \
947 LINE(MAIN_COMMIT,  "",                  COLOR_DEFAULT,  COLOR_DEFAULT,  0), \
948 LINE(MAIN_TAG,     "",                  COLOR_MAGENTA,  COLOR_DEFAULT,  A_BOLD), \
949 LINE(MAIN_LOCAL_TAG,"",                 COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
950 LINE(MAIN_REMOTE,  "",                  COLOR_YELLOW,   COLOR_DEFAULT,  0), \
951 LINE(MAIN_TRACKED, "",                  COLOR_YELLOW,   COLOR_DEFAULT,  A_BOLD), \
952 LINE(MAIN_REF,     "",                  COLOR_CYAN,     COLOR_DEFAULT,  0), \
953 LINE(MAIN_HEAD,    "",                  COLOR_CYAN,     COLOR_DEFAULT,  A_BOLD), \
954 LINE(MAIN_REVGRAPH,"",                  COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
955 LINE(TREE_PARENT,  "",                  COLOR_DEFAULT,  COLOR_DEFAULT,  A_BOLD), \
956 LINE(TREE_MODE,    "",                  COLOR_CYAN,     COLOR_DEFAULT,  0), \
957 LINE(TREE_DIR,     "",                  COLOR_YELLOW,   COLOR_DEFAULT,  A_NORMAL), \
958 LINE(TREE_FILE,    "",                  COLOR_DEFAULT,  COLOR_DEFAULT,  A_NORMAL), \
959 LINE(STAT_HEAD,    "",                  COLOR_YELLOW,   COLOR_DEFAULT,  0), \
960 LINE(STAT_SECTION, "",                  COLOR_CYAN,     COLOR_DEFAULT,  0), \
961 LINE(STAT_NONE,    "",                  COLOR_DEFAULT,  COLOR_DEFAULT,  0), \
962 LINE(STAT_STAGED,  "",                  COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
963 LINE(STAT_UNSTAGED,"",                  COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
964 LINE(STAT_UNTRACKED,"",                 COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
965 LINE(BLAME_ID,     "",                  COLOR_MAGENTA,  COLOR_DEFAULT,  0)
967 enum line_type {
968 #define LINE(type, line, fg, bg, attr) \
969         LINE_##type
970         LINE_INFO,
971         LINE_NONE
972 #undef  LINE
973 };
975 struct line_info {
976         const char *name;       /* Option name. */
977         int namelen;            /* Size of option name. */
978         const char *line;       /* The start of line to match. */
979         int linelen;            /* Size of string to match. */
980         int fg, bg, attr;       /* Color and text attributes for the lines. */
981 };
983 static struct line_info line_info[] = {
984 #define LINE(type, line, fg, bg, attr) \
985         { #type, STRING_SIZE(#type), (line), STRING_SIZE(line), (fg), (bg), (attr) }
986         LINE_INFO
987 #undef  LINE
988 };
990 static enum line_type
991 get_line_type(const char *line)
993         int linelen = strlen(line);
994         enum line_type type;
996         for (type = 0; type < ARRAY_SIZE(line_info); type++)
997                 /* Case insensitive search matches Signed-off-by lines better. */
998                 if (linelen >= line_info[type].linelen &&
999                     !strncasecmp(line_info[type].line, line, line_info[type].linelen))
1000                         return type;
1002         return LINE_DEFAULT;
1005 static inline int
1006 get_line_attr(enum line_type type)
1008         assert(type < ARRAY_SIZE(line_info));
1009         return COLOR_PAIR(type) | line_info[type].attr;
1012 static struct line_info *
1013 get_line_info(const char *name)
1015         size_t namelen = strlen(name);
1016         enum line_type type;
1018         for (type = 0; type < ARRAY_SIZE(line_info); type++)
1019                 if (namelen == line_info[type].namelen &&
1020                     !string_enum_compare(line_info[type].name, name, namelen))
1021                         return &line_info[type];
1023         return NULL;
1026 static void
1027 init_colors(void)
1029         int default_bg = line_info[LINE_DEFAULT].bg;
1030         int default_fg = line_info[LINE_DEFAULT].fg;
1031         enum line_type type;
1033         start_color();
1035         if (assume_default_colors(default_fg, default_bg) == ERR) {
1036                 default_bg = COLOR_BLACK;
1037                 default_fg = COLOR_WHITE;
1038         }
1040         for (type = 0; type < ARRAY_SIZE(line_info); type++) {
1041                 struct line_info *info = &line_info[type];
1042                 int bg = info->bg == COLOR_DEFAULT ? default_bg : info->bg;
1043                 int fg = info->fg == COLOR_DEFAULT ? default_fg : info->fg;
1045                 init_pair(type, fg, bg);
1046         }
1049 struct line {
1050         enum line_type type;
1052         /* State flags */
1053         unsigned int selected:1;
1054         unsigned int dirty:1;
1055         unsigned int cleareol:1;
1057         void *data;             /* User data */
1058 };
1061 /*
1062  * Keys
1063  */
1065 struct keybinding {
1066         int alias;
1067         enum request request;
1068 };
1070 static struct keybinding default_keybindings[] = {
1071         /* View switching */
1072         { 'm',          REQ_VIEW_MAIN },
1073         { 'd',          REQ_VIEW_DIFF },
1074         { 'l',          REQ_VIEW_LOG },
1075         { 't',          REQ_VIEW_TREE },
1076         { 'f',          REQ_VIEW_BLOB },
1077         { 'B',          REQ_VIEW_BLAME },
1078         { 'p',          REQ_VIEW_PAGER },
1079         { 'h',          REQ_VIEW_HELP },
1080         { 'S',          REQ_VIEW_STATUS },
1081         { 'c',          REQ_VIEW_STAGE },
1083         /* View manipulation */
1084         { 'q',          REQ_VIEW_CLOSE },
1085         { KEY_TAB,      REQ_VIEW_NEXT },
1086         { KEY_RETURN,   REQ_ENTER },
1087         { KEY_UP,       REQ_PREVIOUS },
1088         { KEY_DOWN,     REQ_NEXT },
1089         { 'R',          REQ_REFRESH },
1090         { KEY_F(5),     REQ_REFRESH },
1091         { 'O',          REQ_MAXIMIZE },
1093         /* Cursor navigation */
1094         { 'k',          REQ_MOVE_UP },
1095         { 'j',          REQ_MOVE_DOWN },
1096         { KEY_HOME,     REQ_MOVE_FIRST_LINE },
1097         { KEY_END,      REQ_MOVE_LAST_LINE },
1098         { KEY_NPAGE,    REQ_MOVE_PAGE_DOWN },
1099         { ' ',          REQ_MOVE_PAGE_DOWN },
1100         { KEY_PPAGE,    REQ_MOVE_PAGE_UP },
1101         { 'b',          REQ_MOVE_PAGE_UP },
1102         { '-',          REQ_MOVE_PAGE_UP },
1104         /* Scrolling */
1105         { KEY_LEFT,     REQ_SCROLL_LEFT },
1106         { KEY_RIGHT,    REQ_SCROLL_RIGHT },
1107         { KEY_IC,       REQ_SCROLL_LINE_UP },
1108         { KEY_DC,       REQ_SCROLL_LINE_DOWN },
1109         { 'w',          REQ_SCROLL_PAGE_UP },
1110         { 's',          REQ_SCROLL_PAGE_DOWN },
1112         /* Searching */
1113         { '/',          REQ_SEARCH },
1114         { '?',          REQ_SEARCH_BACK },
1115         { 'n',          REQ_FIND_NEXT },
1116         { 'N',          REQ_FIND_PREV },
1118         /* Misc */
1119         { 'Q',          REQ_QUIT },
1120         { 'z',          REQ_STOP_LOADING },
1121         { 'v',          REQ_SHOW_VERSION },
1122         { 'r',          REQ_SCREEN_REDRAW },
1123         { '.',          REQ_TOGGLE_LINENO },
1124         { 'D',          REQ_TOGGLE_DATE },
1125         { 'A',          REQ_TOGGLE_AUTHOR },
1126         { 'g',          REQ_TOGGLE_REV_GRAPH },
1127         { 'F',          REQ_TOGGLE_REFS },
1128         { ':',          REQ_PROMPT },
1129         { 'u',          REQ_STATUS_UPDATE },
1130         { '!',          REQ_STATUS_REVERT },
1131         { 'M',          REQ_STATUS_MERGE },
1132         { '@',          REQ_STAGE_NEXT },
1133         { ',',          REQ_PARENT },
1134         { 'e',          REQ_EDIT },
1135 };
1137 #define KEYMAP_INFO \
1138         KEYMAP_(GENERIC), \
1139         KEYMAP_(MAIN), \
1140         KEYMAP_(DIFF), \
1141         KEYMAP_(LOG), \
1142         KEYMAP_(TREE), \
1143         KEYMAP_(BLOB), \
1144         KEYMAP_(BLAME), \
1145         KEYMAP_(PAGER), \
1146         KEYMAP_(HELP), \
1147         KEYMAP_(STATUS), \
1148         KEYMAP_(STAGE)
1150 enum keymap {
1151 #define KEYMAP_(name) KEYMAP_##name
1152         KEYMAP_INFO
1153 #undef  KEYMAP_
1154 };
1156 static struct int_map keymap_table[] = {
1157 #define KEYMAP_(name) { #name, STRING_SIZE(#name), KEYMAP_##name }
1158         KEYMAP_INFO
1159 #undef  KEYMAP_
1160 };
1162 #define set_keymap(map, name) \
1163         set_from_int_map(keymap_table, ARRAY_SIZE(keymap_table), map, name, strlen(name))
1165 struct keybinding_table {
1166         struct keybinding *data;
1167         size_t size;
1168 };
1170 static struct keybinding_table keybindings[ARRAY_SIZE(keymap_table)];
1172 static void
1173 add_keybinding(enum keymap keymap, enum request request, int key)
1175         struct keybinding_table *table = &keybindings[keymap];
1177         table->data = realloc(table->data, (table->size + 1) * sizeof(*table->data));
1178         if (!table->data)
1179                 die("Failed to allocate keybinding");
1180         table->data[table->size].alias = key;
1181         table->data[table->size++].request = request;
1184 /* Looks for a key binding first in the given map, then in the generic map, and
1185  * lastly in the default keybindings. */
1186 static enum request
1187 get_keybinding(enum keymap keymap, int key)
1189         size_t i;
1191         for (i = 0; i < keybindings[keymap].size; i++)
1192                 if (keybindings[keymap].data[i].alias == key)
1193                         return keybindings[keymap].data[i].request;
1195         for (i = 0; i < keybindings[KEYMAP_GENERIC].size; i++)
1196                 if (keybindings[KEYMAP_GENERIC].data[i].alias == key)
1197                         return keybindings[KEYMAP_GENERIC].data[i].request;
1199         for (i = 0; i < ARRAY_SIZE(default_keybindings); i++)
1200                 if (default_keybindings[i].alias == key)
1201                         return default_keybindings[i].request;
1203         return (enum request) key;
1207 struct key {
1208         const char *name;
1209         int value;
1210 };
1212 static struct key key_table[] = {
1213         { "Enter",      KEY_RETURN },
1214         { "Space",      ' ' },
1215         { "Backspace",  KEY_BACKSPACE },
1216         { "Tab",        KEY_TAB },
1217         { "Escape",     KEY_ESC },
1218         { "Left",       KEY_LEFT },
1219         { "Right",      KEY_RIGHT },
1220         { "Up",         KEY_UP },
1221         { "Down",       KEY_DOWN },
1222         { "Insert",     KEY_IC },
1223         { "Delete",     KEY_DC },
1224         { "Hash",       '#' },
1225         { "Home",       KEY_HOME },
1226         { "End",        KEY_END },
1227         { "PageUp",     KEY_PPAGE },
1228         { "PageDown",   KEY_NPAGE },
1229         { "F1",         KEY_F(1) },
1230         { "F2",         KEY_F(2) },
1231         { "F3",         KEY_F(3) },
1232         { "F4",         KEY_F(4) },
1233         { "F5",         KEY_F(5) },
1234         { "F6",         KEY_F(6) },
1235         { "F7",         KEY_F(7) },
1236         { "F8",         KEY_F(8) },
1237         { "F9",         KEY_F(9) },
1238         { "F10",        KEY_F(10) },
1239         { "F11",        KEY_F(11) },
1240         { "F12",        KEY_F(12) },
1241 };
1243 static int
1244 get_key_value(const char *name)
1246         int i;
1248         for (i = 0; i < ARRAY_SIZE(key_table); i++)
1249                 if (!strcasecmp(key_table[i].name, name))
1250                         return key_table[i].value;
1252         if (strlen(name) == 1 && isprint(*name))
1253                 return (int) *name;
1255         return ERR;
1258 static const char *
1259 get_key_name(int key_value)
1261         static char key_char[] = "'X'";
1262         const char *seq = NULL;
1263         int key;
1265         for (key = 0; key < ARRAY_SIZE(key_table); key++)
1266                 if (key_table[key].value == key_value)
1267                         seq = key_table[key].name;
1269         if (seq == NULL &&
1270             key_value < 127 &&
1271             isprint(key_value)) {
1272                 key_char[1] = (char) key_value;
1273                 seq = key_char;
1274         }
1276         return seq ? seq : "(no key)";
1279 static const char *
1280 get_key(enum request request)
1282         static char buf[BUFSIZ];
1283         size_t pos = 0;
1284         char *sep = "";
1285         int i;
1287         buf[pos] = 0;
1289         for (i = 0; i < ARRAY_SIZE(default_keybindings); i++) {
1290                 struct keybinding *keybinding = &default_keybindings[i];
1292                 if (keybinding->request != request)
1293                         continue;
1295                 if (!string_format_from(buf, &pos, "%s%s", sep,
1296                                         get_key_name(keybinding->alias)))
1297                         return "Too many keybindings!";
1298                 sep = ", ";
1299         }
1301         return buf;
1304 struct run_request {
1305         enum keymap keymap;
1306         int key;
1307         const char *argv[SIZEOF_ARG];
1308 };
1310 static struct run_request *run_request;
1311 static size_t run_requests;
1313 static enum request
1314 add_run_request(enum keymap keymap, int key, int argc, const char **argv)
1316         struct run_request *req;
1318         if (argc >= ARRAY_SIZE(req->argv) - 1)
1319                 return REQ_NONE;
1321         req = realloc(run_request, (run_requests + 1) * sizeof(*run_request));
1322         if (!req)
1323                 return REQ_NONE;
1325         run_request = req;
1326         req = &run_request[run_requests];
1327         req->keymap = keymap;
1328         req->key = key;
1329         req->argv[0] = NULL;
1331         if (!format_argv(req->argv, argv, FORMAT_NONE))
1332                 return REQ_NONE;
1334         return REQ_NONE + ++run_requests;
1337 static struct run_request *
1338 get_run_request(enum request request)
1340         if (request <= REQ_NONE)
1341                 return NULL;
1342         return &run_request[request - REQ_NONE - 1];
1345 static void
1346 add_builtin_run_requests(void)
1348         const char *cherry_pick[] = { "git", "cherry-pick", "%(commit)", NULL };
1349         const char *gc[] = { "git", "gc", NULL };
1350         struct {
1351                 enum keymap keymap;
1352                 int key;
1353                 int argc;
1354                 const char **argv;
1355         } reqs[] = {
1356                 { KEYMAP_MAIN,    'C', ARRAY_SIZE(cherry_pick) - 1, cherry_pick },
1357                 { KEYMAP_GENERIC, 'G', ARRAY_SIZE(gc) - 1, gc },
1358         };
1359         int i;
1361         for (i = 0; i < ARRAY_SIZE(reqs); i++) {
1362                 enum request req;
1364                 req = add_run_request(reqs[i].keymap, reqs[i].key, reqs[i].argc, reqs[i].argv);
1365                 if (req != REQ_NONE)
1366                         add_keybinding(reqs[i].keymap, req, reqs[i].key);
1367         }
1370 /*
1371  * User config file handling.
1372  */
1374 static struct int_map color_map[] = {
1375 #define COLOR_MAP(name) { #name, STRING_SIZE(#name), COLOR_##name }
1376         COLOR_MAP(DEFAULT),
1377         COLOR_MAP(BLACK),
1378         COLOR_MAP(BLUE),
1379         COLOR_MAP(CYAN),
1380         COLOR_MAP(GREEN),
1381         COLOR_MAP(MAGENTA),
1382         COLOR_MAP(RED),
1383         COLOR_MAP(WHITE),
1384         COLOR_MAP(YELLOW),
1385 };
1387 #define set_color(color, name) \
1388         set_from_int_map(color_map, ARRAY_SIZE(color_map), color, name, strlen(name))
1390 static struct int_map attr_map[] = {
1391 #define ATTR_MAP(name) { #name, STRING_SIZE(#name), A_##name }
1392         ATTR_MAP(NORMAL),
1393         ATTR_MAP(BLINK),
1394         ATTR_MAP(BOLD),
1395         ATTR_MAP(DIM),
1396         ATTR_MAP(REVERSE),
1397         ATTR_MAP(STANDOUT),
1398         ATTR_MAP(UNDERLINE),
1399 };
1401 #define set_attribute(attr, name) \
1402         set_from_int_map(attr_map, ARRAY_SIZE(attr_map), attr, name, strlen(name))
1404 static int   config_lineno;
1405 static bool  config_errors;
1406 static const char *config_msg;
1408 /* Wants: object fgcolor bgcolor [attr] */
1409 static int
1410 option_color_command(int argc, const char *argv[])
1412         struct line_info *info;
1414         if (argc != 3 && argc != 4) {
1415                 config_msg = "Wrong number of arguments given to color command";
1416                 return ERR;
1417         }
1419         info = get_line_info(argv[0]);
1420         if (!info) {
1421                 if (!string_enum_compare(argv[0], "main-delim", strlen("main-delim"))) {
1422                         info = get_line_info("delimiter");
1424                 } else if (!string_enum_compare(argv[0], "main-date", strlen("main-date"))) {
1425                         info = get_line_info("date");
1427                 } else {
1428                         config_msg = "Unknown color name";
1429                         return ERR;
1430                 }
1431         }
1433         if (set_color(&info->fg, argv[1]) == ERR ||
1434             set_color(&info->bg, argv[2]) == ERR) {
1435                 config_msg = "Unknown color";
1436                 return ERR;
1437         }
1439         if (argc == 4 && set_attribute(&info->attr, argv[3]) == ERR) {
1440                 config_msg = "Unknown attribute";
1441                 return ERR;
1442         }
1444         return OK;
1447 static bool parse_bool(const char *s)
1449         return (!strcmp(s, "1") || !strcmp(s, "true") ||
1450                 !strcmp(s, "yes")) ? TRUE : FALSE;
1453 static int
1454 parse_int(const char *s, int default_value, int min, int max)
1456         int value = atoi(s);
1458         return (value < min || value > max) ? default_value : value;
1461 /* Wants: name = value */
1462 static int
1463 option_set_command(int argc, const char *argv[])
1465         if (argc != 3) {
1466                 config_msg = "Wrong number of arguments given to set command";
1467                 return ERR;
1468         }
1470         if (strcmp(argv[1], "=")) {
1471                 config_msg = "No value assigned";
1472                 return ERR;
1473         }
1475         if (!strcmp(argv[0], "show-author")) {
1476                 opt_author = parse_bool(argv[2]);
1477                 return OK;
1478         }
1480         if (!strcmp(argv[0], "show-date")) {
1481                 opt_date = parse_bool(argv[2]);
1482                 return OK;
1483         }
1485         if (!strcmp(argv[0], "show-rev-graph")) {
1486                 opt_rev_graph = parse_bool(argv[2]);
1487                 return OK;
1488         }
1490         if (!strcmp(argv[0], "show-refs")) {
1491                 opt_show_refs = parse_bool(argv[2]);
1492                 return OK;
1493         }
1495         if (!strcmp(argv[0], "show-line-numbers")) {
1496                 opt_line_number = parse_bool(argv[2]);
1497                 return OK;
1498         }
1500         if (!strcmp(argv[0], "line-graphics")) {
1501                 opt_line_graphics = parse_bool(argv[2]);
1502                 return OK;
1503         }
1505         if (!strcmp(argv[0], "line-number-interval")) {
1506                 opt_num_interval = parse_int(argv[2], opt_num_interval, 1, 1024);
1507                 return OK;
1508         }
1510         if (!strcmp(argv[0], "author-width")) {
1511                 opt_author_cols = parse_int(argv[2], opt_author_cols, 0, 1024);
1512                 return OK;
1513         }
1515         if (!strcmp(argv[0], "tab-size")) {
1516                 opt_tab_size = parse_int(argv[2], opt_tab_size, 1, 1024);
1517                 return OK;
1518         }
1520         if (!strcmp(argv[0], "commit-encoding")) {
1521                 const char *arg = argv[2];
1522                 int arglen = strlen(arg);
1524                 switch (arg[0]) {
1525                 case '"':
1526                 case '\'':
1527                         if (arglen == 1 || arg[arglen - 1] != arg[0]) {
1528                                 config_msg = "Unmatched quotation";
1529                                 return ERR;
1530                         }
1531                         arg += 1; arglen -= 2;
1532                 default:
1533                         string_ncopy(opt_encoding, arg, strlen(arg));
1534                         return OK;
1535                 }
1536         }
1538         config_msg = "Unknown variable name";
1539         return ERR;
1542 /* Wants: mode request key */
1543 static int
1544 option_bind_command(int argc, const char *argv[])
1546         enum request request;
1547         int keymap;
1548         int key;
1550         if (argc < 3) {
1551                 config_msg = "Wrong number of arguments given to bind command";
1552                 return ERR;
1553         }
1555         if (set_keymap(&keymap, argv[0]) == ERR) {
1556                 config_msg = "Unknown key map";
1557                 return ERR;
1558         }
1560         key = get_key_value(argv[1]);
1561         if (key == ERR) {
1562                 config_msg = "Unknown key";
1563                 return ERR;
1564         }
1566         request = get_request(argv[2]);
1567         if (request == REQ_NONE) {
1568                 struct {
1569                         const char *name;
1570                         enum request request;
1571                 } obsolete[] = {
1572                         { "cherry-pick",        REQ_NONE },
1573                         { "screen-resize",      REQ_NONE },
1574                         { "tree-parent",        REQ_PARENT },
1575                 };
1576                 size_t namelen = strlen(argv[2]);
1577                 int i;
1579                 for (i = 0; i < ARRAY_SIZE(obsolete); i++) {
1580                         if (namelen != strlen(obsolete[i].name) ||
1581                             string_enum_compare(obsolete[i].name, argv[2], namelen))
1582                                 continue;
1583                         if (obsolete[i].request != REQ_NONE)
1584                                 add_keybinding(keymap, obsolete[i].request, key);
1585                         config_msg = "Obsolete request name";
1586                         return ERR;
1587                 }
1588         }
1589         if (request == REQ_NONE && *argv[2]++ == '!')
1590                 request = add_run_request(keymap, key, argc - 2, argv + 2);
1591         if (request == REQ_NONE) {
1592                 config_msg = "Unknown request name";
1593                 return ERR;
1594         }
1596         add_keybinding(keymap, request, key);
1598         return OK;
1601 static int
1602 set_option(const char *opt, char *value)
1604         const char *argv[SIZEOF_ARG];
1605         int argc = 0;
1607         if (!argv_from_string(argv, &argc, value)) {
1608                 config_msg = "Too many option arguments";
1609                 return ERR;
1610         }
1612         if (!strcmp(opt, "color"))
1613                 return option_color_command(argc, argv);
1615         if (!strcmp(opt, "set"))
1616                 return option_set_command(argc, argv);
1618         if (!strcmp(opt, "bind"))
1619                 return option_bind_command(argc, argv);
1621         config_msg = "Unknown option command";
1622         return ERR;
1625 static int
1626 read_option(char *opt, size_t optlen, char *value, size_t valuelen)
1628         int status = OK;
1630         config_lineno++;
1631         config_msg = "Internal error";
1633         /* Check for comment markers, since read_properties() will
1634          * only ensure opt and value are split at first " \t". */
1635         optlen = strcspn(opt, "#");
1636         if (optlen == 0)
1637                 return OK;
1639         if (opt[optlen] != 0) {
1640                 config_msg = "No option value";
1641                 status = ERR;
1643         }  else {
1644                 /* Look for comment endings in the value. */
1645                 size_t len = strcspn(value, "#");
1647                 if (len < valuelen) {
1648                         valuelen = len;
1649                         value[valuelen] = 0;
1650                 }
1652                 status = set_option(opt, value);
1653         }
1655         if (status == ERR) {
1656                 warn("Error on line %d, near '%.*s': %s",
1657                      config_lineno, (int) optlen, opt, config_msg);
1658                 config_errors = TRUE;
1659         }
1661         /* Always keep going if errors are encountered. */
1662         return OK;
1665 static void
1666 load_option_file(const char *path)
1668         struct io io = {};
1670         /* It's ok that the file doesn't exist. */
1671         if (!io_open(&io, path))
1672                 return;
1674         config_lineno = 0;
1675         config_errors = FALSE;
1677         if (io_load(&io, " \t", read_option) == ERR ||
1678             config_errors == TRUE)
1679                 warn("Errors while loading %s.", path);
1682 static int
1683 load_options(void)
1685         const char *home = getenv("HOME");
1686         const char *tigrc_user = getenv("TIGRC_USER");
1687         const char *tigrc_system = getenv("TIGRC_SYSTEM");
1688         char buf[SIZEOF_STR];
1690         add_builtin_run_requests();
1692         if (!tigrc_system) {
1693                 if (!string_format(buf, "%s/tigrc", SYSCONFDIR))
1694                         return ERR;
1695                 tigrc_system = buf;
1696         }
1697         load_option_file(tigrc_system);
1699         if (!tigrc_user) {
1700                 if (!home || !string_format(buf, "%s/.tigrc", home))
1701                         return ERR;
1702                 tigrc_user = buf;
1703         }
1704         load_option_file(tigrc_user);
1706         return OK;
1710 /*
1711  * The viewer
1712  */
1714 struct view;
1715 struct view_ops;
1717 /* The display array of active views and the index of the current view. */
1718 static struct view *display[2];
1719 static unsigned int current_view;
1721 #define foreach_displayed_view(view, i) \
1722         for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
1724 #define displayed_views()       (display[1] != NULL ? 2 : 1)
1726 /* Current head and commit ID */
1727 static char ref_blob[SIZEOF_REF]        = "";
1728 static char ref_commit[SIZEOF_REF]      = "HEAD";
1729 static char ref_head[SIZEOF_REF]        = "HEAD";
1731 struct view {
1732         const char *name;       /* View name */
1733         const char *cmd_env;    /* Command line set via environment */
1734         const char *id;         /* Points to either of ref_{head,commit,blob} */
1736         struct view_ops *ops;   /* View operations */
1738         enum keymap keymap;     /* What keymap does this view have */
1739         bool git_dir;           /* Whether the view requires a git directory. */
1741         char ref[SIZEOF_REF];   /* Hovered commit reference */
1742         char vid[SIZEOF_REF];   /* View ID. Set to id member when updating. */
1744         int height, width;      /* The width and height of the main window */
1745         WINDOW *win;            /* The main window */
1746         WINDOW *title;          /* The title window living below the main window */
1748         /* Navigation */
1749         unsigned long offset;   /* Offset of the window top */
1750         unsigned long yoffset;  /* Offset from the window side. */
1751         unsigned long lineno;   /* Current line number */
1752         unsigned long p_offset; /* Previous offset of the window top */
1753         unsigned long p_yoffset;/* Previous offset from the window side */
1754         unsigned long p_lineno; /* Previous current line number */
1755         bool p_restore;         /* Should the previous position be restored. */
1757         /* Searching */
1758         char grep[SIZEOF_STR];  /* Search string */
1759         regex_t *regex;         /* Pre-compiled regex */
1761         /* If non-NULL, points to the view that opened this view. If this view
1762          * is closed tig will switch back to the parent view. */
1763         struct view *parent;
1765         /* Buffering */
1766         size_t lines;           /* Total number of lines */
1767         struct line *line;      /* Line index */
1768         size_t line_alloc;      /* Total number of allocated lines */
1769         unsigned int digits;    /* Number of digits in the lines member. */
1771         /* Drawing */
1772         struct line *curline;   /* Line currently being drawn. */
1773         enum line_type curtype; /* Attribute currently used for drawing. */
1774         unsigned long col;      /* Column when drawing. */
1775         bool has_scrolled;      /* View was scrolled. */
1776         bool can_hscroll;       /* View can be scrolled horizontally. */
1778         /* Loading */
1779         struct io io;
1780         struct io *pipe;
1781         time_t start_time;
1782         time_t update_secs;
1783 };
1785 struct view_ops {
1786         /* What type of content being displayed. Used in the title bar. */
1787         const char *type;
1788         /* Default command arguments. */
1789         const char **argv;
1790         /* Open and reads in all view content. */
1791         bool (*open)(struct view *view);
1792         /* Read one line; updates view->line. */
1793         bool (*read)(struct view *view, char *data);
1794         /* Draw one line; @lineno must be < view->height. */
1795         bool (*draw)(struct view *view, struct line *line, unsigned int lineno);
1796         /* Depending on view handle a special requests. */
1797         enum request (*request)(struct view *view, enum request request, struct line *line);
1798         /* Search for regex in a line. */
1799         bool (*grep)(struct view *view, struct line *line);
1800         /* Select line */
1801         void (*select)(struct view *view, struct line *line);
1802 };
1804 static struct view_ops blame_ops;
1805 static struct view_ops blob_ops;
1806 static struct view_ops diff_ops;
1807 static struct view_ops help_ops;
1808 static struct view_ops log_ops;
1809 static struct view_ops main_ops;
1810 static struct view_ops pager_ops;
1811 static struct view_ops stage_ops;
1812 static struct view_ops status_ops;
1813 static struct view_ops tree_ops;
1815 #define VIEW_STR(name, env, ref, ops, map, git) \
1816         { name, #env, ref, ops, map, git }
1818 #define VIEW_(id, name, ops, git, ref) \
1819         VIEW_STR(name, TIG_##id##_CMD, ref, ops, KEYMAP_##id, git)
1822 static struct view views[] = {
1823         VIEW_(MAIN,   "main",   &main_ops,   TRUE,  ref_head),
1824         VIEW_(DIFF,   "diff",   &diff_ops,   TRUE,  ref_commit),
1825         VIEW_(LOG,    "log",    &log_ops,    TRUE,  ref_head),
1826         VIEW_(TREE,   "tree",   &tree_ops,   TRUE,  ref_commit),
1827         VIEW_(BLOB,   "blob",   &blob_ops,   TRUE,  ref_blob),
1828         VIEW_(BLAME,  "blame",  &blame_ops,  TRUE,  ref_commit),
1829         VIEW_(HELP,   "help",   &help_ops,   FALSE, ""),
1830         VIEW_(PAGER,  "pager",  &pager_ops,  FALSE, "stdin"),
1831         VIEW_(STATUS, "status", &status_ops, TRUE,  ""),
1832         VIEW_(STAGE,  "stage",  &stage_ops,  TRUE,  ""),
1833 };
1835 #define VIEW(req)       (&views[(req) - REQ_OFFSET - 1])
1836 #define VIEW_REQ(view)  ((view) - views + REQ_OFFSET + 1)
1838 #define foreach_view(view, i) \
1839         for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
1841 #define view_is_displayed(view) \
1842         (view == display[0] || view == display[1])
1845 enum line_graphic {
1846         LINE_GRAPHIC_VLINE
1847 };
1849 static int line_graphics[] = {
1850         /* LINE_GRAPHIC_VLINE: */ '|'
1851 };
1853 static inline void
1854 set_view_attr(struct view *view, enum line_type type)
1856         if (!view->curline->selected && view->curtype != type) {
1857                 wattrset(view->win, get_line_attr(type));
1858                 wchgat(view->win, -1, 0, type, NULL);
1859                 view->curtype = type;
1860         }
1863 static int
1864 draw_chars(struct view *view, enum line_type type, const char *string,
1865            int max_len, bool use_tilde)
1867         int len = 0;
1868         int col = 0;
1869         int trimmed = FALSE;
1870         size_t skip = view->yoffset > view->col ? view->yoffset - view->col : 0;
1872         if (max_len <= 0)
1873                 return 0;
1875         if (opt_utf8) {
1876                 len = utf8_length(&string, skip, &col, max_len, &trimmed, use_tilde);
1877         } else {
1878                 col = len = strlen(string);
1879                 if (len > max_len) {
1880                         if (use_tilde) {
1881                                 max_len -= 1;
1882                         }
1883                         col = len = max_len;
1884                         trimmed = TRUE;
1885                 }
1886         }
1888         set_view_attr(view, type);
1889         if (len > 0)
1890                 waddnstr(view->win, string, len);
1891         if (trimmed && use_tilde) {
1892                 set_view_attr(view, LINE_DELIMITER);
1893                 waddch(view->win, '~');
1894                 col++;
1895         }
1897         if (view->col + col >= view->width + view->yoffset)
1898                 view->can_hscroll = TRUE;
1900         return col;
1903 static int
1904 draw_space(struct view *view, enum line_type type, int max, int spaces)
1906         static char space[] = "                    ";
1907         int col = 0;
1909         spaces = MIN(max, spaces);
1911         while (spaces > 0) {
1912                 int len = MIN(spaces, sizeof(space) - 1);
1914                 col += draw_chars(view, type, space, spaces, FALSE);
1915                 spaces -= len;
1916         }
1918         return col;
1921 static bool
1922 draw_lineno(struct view *view, unsigned int lineno)
1924         size_t skip = view->yoffset > view->col ? view->yoffset - view->col : 0;
1925         char number[10];
1926         int digits3 = view->digits < 3 ? 3 : view->digits;
1927         int max_number = MIN(digits3, STRING_SIZE(number));
1928         int max = view->width - view->col;
1929         int col;
1931         if (max < max_number)
1932                 max_number = max;
1934         lineno += view->offset + 1;
1935         if (lineno == 1 || (lineno % opt_num_interval) == 0) {
1936                 static char fmt[] = "%1ld";
1938                 if (view->digits <= 9)
1939                         fmt[1] = '0' + digits3;
1941                 if (!string_format(number, fmt, lineno))
1942                         number[0] = 0;
1943                 col = draw_chars(view, LINE_LINE_NUMBER, number, max_number, TRUE);
1944         } else {
1945                 col = draw_space(view, LINE_LINE_NUMBER, max_number, max_number);
1946         }
1948         if (col < max && skip <= col) {
1949                 set_view_attr(view, LINE_DEFAULT);
1950                 waddch(view->win, line_graphics[LINE_GRAPHIC_VLINE]);
1951         }
1952         col++;
1954         view->col += col;
1955         if (col < max && skip <= col)
1956                 col = draw_space(view, LINE_DEFAULT, max - col, 1);
1957         view->col++;
1959         return view->width + view->yoffset <= view->col;
1962 static bool
1963 draw_text(struct view *view, enum line_type type, const char *string, bool trim)
1965         view->col += draw_chars(view, type, string, view->width + view->yoffset - view->col, trim);
1966         return view->width - view->col <= 0;
1969 static bool
1970 draw_graphic(struct view *view, enum line_type type, chtype graphic[], size_t size)
1972         size_t skip = view->yoffset > view->col ? view->yoffset - view->col : 0;
1973         int max = view->width - view->col;
1974         int i;
1976         if (max < size)
1977                 size = max;
1979         set_view_attr(view, type);
1980         /* Using waddch() instead of waddnstr() ensures that
1981          * they'll be rendered correctly for the cursor line. */
1982         for (i = skip; i < size; i++)
1983                 waddch(view->win, graphic[i]);
1985         view->col += size;
1986         if (size < max && skip <= size)
1987                 waddch(view->win, ' ');
1988         view->col++;
1990         return view->width - view->col <= 0;
1993 static bool
1994 draw_field(struct view *view, enum line_type type, const char *text, int len, bool trim)
1996         int max = MIN(view->width - view->col, len);
1997         int col;
1999         if (text)
2000                 col = draw_chars(view, type, text, max - 1, trim);
2001         else
2002                 col = draw_space(view, type, max - 1, max - 1);
2004         view->col += col;
2005         view->col += draw_space(view, LINE_DEFAULT, max - col, max - col);
2006         return view->width + view->yoffset <= view->col;
2009 static bool
2010 draw_date(struct view *view, struct tm *time)
2012         char buf[DATE_COLS];
2013         char *date;
2014         int timelen = 0;
2016         if (time)
2017                 timelen = strftime(buf, sizeof(buf), DATE_FORMAT, time);
2018         date = timelen ? buf : NULL;
2020         return draw_field(view, LINE_DATE, date, DATE_COLS, FALSE);
2023 static bool
2024 draw_author(struct view *view, const char *author)
2026         bool trim = opt_author_cols == 0 || opt_author_cols > 5 || !author;
2028         if (!trim) {
2029                 static char initials[10];
2030                 size_t pos;
2032 #define is_initial_sep(c) (isspace(c) || ispunct(c) || (c) == '@')
2034                 memset(initials, 0, sizeof(initials));
2035                 for (pos = 0; *author && pos < opt_author_cols - 1; author++, pos++) {
2036                         while (is_initial_sep(*author))
2037                                 author++;
2038                         strncpy(&initials[pos], author, sizeof(initials) - 1 - pos);
2039                         while (*author && !is_initial_sep(author[1]))
2040                                 author++;
2041                 }
2043                 author = initials;
2044         }
2046         return draw_field(view, LINE_MAIN_AUTHOR, author, opt_author_cols, trim);
2049 static bool
2050 draw_view_line(struct view *view, unsigned int lineno)
2052         struct line *line;
2053         bool selected = (view->offset + lineno == view->lineno);
2055         assert(view_is_displayed(view));
2057         if (view->offset + lineno >= view->lines)
2058                 return FALSE;
2060         line = &view->line[view->offset + lineno];
2062         wmove(view->win, lineno, 0);
2063         if (line->cleareol)
2064                 wclrtoeol(view->win);
2065         view->col = 0;
2066         view->curline = line;
2067         view->curtype = LINE_NONE;
2068         line->selected = FALSE;
2069         line->dirty = line->cleareol = 0;
2071         if (selected) {
2072                 set_view_attr(view, LINE_CURSOR);
2073                 line->selected = TRUE;
2074                 view->ops->select(view, line);
2075         }
2077         return view->ops->draw(view, line, lineno);
2080 static void
2081 redraw_view_dirty(struct view *view)
2083         bool dirty = FALSE;
2084         int lineno;
2086         for (lineno = 0; lineno < view->height; lineno++) {
2087                 if (view->offset + lineno >= view->lines)
2088                         break;
2089                 if (!view->line[view->offset + lineno].dirty)
2090                         continue;
2091                 dirty = TRUE;
2092                 if (!draw_view_line(view, lineno))
2093                         break;
2094         }
2096         if (!dirty)
2097                 return;
2098         wnoutrefresh(view->win);
2101 static void
2102 redraw_view_from(struct view *view, int lineno)
2104         assert(0 <= lineno && lineno < view->height);
2106         if (lineno == 0)
2107                 view->can_hscroll = FALSE;
2109         for (; lineno < view->height; lineno++) {
2110                 if (!draw_view_line(view, lineno))
2111                         break;
2112         }
2114         wnoutrefresh(view->win);
2117 static void
2118 redraw_view(struct view *view)
2120         werase(view->win);
2121         redraw_view_from(view, 0);
2125 static void
2126 update_view_title(struct view *view)
2128         char buf[SIZEOF_STR];
2129         char state[SIZEOF_STR];
2130         size_t bufpos = 0, statelen = 0;
2132         assert(view_is_displayed(view));
2134         if (view != VIEW(REQ_VIEW_STATUS) && view->lines) {
2135                 unsigned int view_lines = view->offset + view->height;
2136                 unsigned int lines = view->lines
2137                                    ? MIN(view_lines, view->lines) * 100 / view->lines
2138                                    : 0;
2140                 string_format_from(state, &statelen, " - %s %d of %d (%d%%)",
2141                                    view->ops->type,
2142                                    view->lineno + 1,
2143                                    view->lines,
2144                                    lines);
2146         }
2148         if (view->pipe) {
2149                 time_t secs = time(NULL) - view->start_time;
2151                 /* Three git seconds are a long time ... */
2152                 if (secs > 2)
2153                         string_format_from(state, &statelen, " loading %lds", secs);
2154         }
2156         string_format_from(buf, &bufpos, "[%s]", view->name);
2157         if (*view->ref && bufpos < view->width) {
2158                 size_t refsize = strlen(view->ref);
2159                 size_t minsize = bufpos + 1 + /* abbrev= */ 7 + 1 + statelen;
2161                 if (minsize < view->width)
2162                         refsize = view->width - minsize + 7;
2163                 string_format_from(buf, &bufpos, " %.*s", (int) refsize, view->ref);
2164         }
2166         if (statelen && bufpos < view->width) {
2167                 string_format_from(buf, &bufpos, "%s", state);
2168         }
2170         if (view == display[current_view])
2171                 wbkgdset(view->title, get_line_attr(LINE_TITLE_FOCUS));
2172         else
2173                 wbkgdset(view->title, get_line_attr(LINE_TITLE_BLUR));
2175         mvwaddnstr(view->title, 0, 0, buf, bufpos);
2176         wclrtoeol(view->title);
2177         wnoutrefresh(view->title);
2180 static void
2181 resize_display(void)
2183         int offset, i;
2184         struct view *base = display[0];
2185         struct view *view = display[1] ? display[1] : display[0];
2187         /* Setup window dimensions */
2189         getmaxyx(stdscr, base->height, base->width);
2191         /* Make room for the status window. */
2192         base->height -= 1;
2194         if (view != base) {
2195                 /* Horizontal split. */
2196                 view->width   = base->width;
2197                 view->height  = SCALE_SPLIT_VIEW(base->height);
2198                 base->height -= view->height;
2200                 /* Make room for the title bar. */
2201                 view->height -= 1;
2202         }
2204         /* Make room for the title bar. */
2205         base->height -= 1;
2207         offset = 0;
2209         foreach_displayed_view (view, i) {
2210                 if (!view->win) {
2211                         view->win = newwin(view->height, 0, offset, 0);
2212                         if (!view->win)
2213                                 die("Failed to create %s view", view->name);
2215                         scrollok(view->win, FALSE);
2217                         view->title = newwin(1, 0, offset + view->height, 0);
2218                         if (!view->title)
2219                                 die("Failed to create title window");
2221                 } else {
2222                         wresize(view->win, view->height, view->width);
2223                         mvwin(view->win,   offset, 0);
2224                         mvwin(view->title, offset + view->height, 0);
2225                 }
2227                 offset += view->height + 1;
2228         }
2231 static void
2232 redraw_display(bool clear)
2234         struct view *view;
2235         int i;
2237         foreach_displayed_view (view, i) {
2238                 if (clear)
2239                         wclear(view->win);
2240                 redraw_view(view);
2241                 update_view_title(view);
2242         }
2245 static void
2246 toggle_view_option(bool *option, const char *help)
2248         *option = !*option;
2249         redraw_display(FALSE);
2250         report("%sabling %s", *option ? "En" : "Dis", help);
2253 /*
2254  * Navigation
2255  */
2257 /* Scrolling backend */
2258 static void
2259 do_scroll_view(struct view *view, int lines)
2261         bool redraw_current_line = FALSE;
2263         /* The rendering expects the new offset. */
2264         view->offset += lines;
2266         assert(0 <= view->offset && view->offset < view->lines);
2267         assert(lines);
2269         /* Move current line into the view. */
2270         if (view->lineno < view->offset) {
2271                 view->lineno = view->offset;
2272                 redraw_current_line = TRUE;
2273         } else if (view->lineno >= view->offset + view->height) {
2274                 view->lineno = view->offset + view->height - 1;
2275                 redraw_current_line = TRUE;
2276         }
2278         assert(view->offset <= view->lineno && view->lineno < view->lines);
2280         /* Redraw the whole screen if scrolling is pointless. */
2281         if (view->height < ABS(lines)) {
2282                 redraw_view(view);
2284         } else {
2285                 int line = lines > 0 ? view->height - lines : 0;
2286                 int end = line + ABS(lines);
2288                 scrollok(view->win, TRUE);
2289                 wscrl(view->win, lines);
2290                 scrollok(view->win, FALSE);
2292                 while (line < end && draw_view_line(view, line))
2293                         line++;
2295                 if (redraw_current_line)
2296                         draw_view_line(view, view->lineno - view->offset);
2297                 wnoutrefresh(view->win);
2298         }
2300         view->has_scrolled = TRUE;
2301         report("");
2304 /* Scroll frontend */
2305 static void
2306 scroll_view(struct view *view, enum request request)
2308         int lines = 1;
2310         assert(view_is_displayed(view));
2312         switch (request) {
2313         case REQ_SCROLL_LEFT:
2314                 if (view->yoffset == 0) {
2315                         report("Cannot scroll beyond the first column");
2316                         return;
2317                 }
2318                 if (view->yoffset <= SCROLL_INTERVAL)
2319                         view->yoffset = 0;
2320                 else
2321                         view->yoffset -= SCROLL_INTERVAL;
2322                 redraw_view_from(view, 0);
2323                 report("");
2324                 return;
2325         case REQ_SCROLL_RIGHT:
2326                 if (!view->can_hscroll) {
2327                         report("Cannot scroll beyond the last column");
2328                         return;
2329                 }
2330                 view->yoffset += SCROLL_INTERVAL;
2331                 redraw_view(view);
2332                 report("");
2333                 return;
2334         case REQ_SCROLL_PAGE_DOWN:
2335                 lines = view->height;
2336         case REQ_SCROLL_LINE_DOWN:
2337                 if (view->offset + lines > view->lines)
2338                         lines = view->lines - view->offset;
2340                 if (lines == 0 || view->offset + view->height >= view->lines) {
2341                         report("Cannot scroll beyond the last line");
2342                         return;
2343                 }
2344                 break;
2346         case REQ_SCROLL_PAGE_UP:
2347                 lines = view->height;
2348         case REQ_SCROLL_LINE_UP:
2349                 if (lines > view->offset)
2350                         lines = view->offset;
2352                 if (lines == 0) {
2353                         report("Cannot scroll beyond the first line");
2354                         return;
2355                 }
2357                 lines = -lines;
2358                 break;
2360         default:
2361                 die("request %d not handled in switch", request);
2362         }
2364         do_scroll_view(view, lines);
2367 /* Cursor moving */
2368 static void
2369 move_view(struct view *view, enum request request)
2371         int scroll_steps = 0;
2372         int steps;
2374         switch (request) {
2375         case REQ_MOVE_FIRST_LINE:
2376                 steps = -view->lineno;
2377                 break;
2379         case REQ_MOVE_LAST_LINE:
2380                 steps = view->lines - view->lineno - 1;
2381                 break;
2383         case REQ_MOVE_PAGE_UP:
2384                 steps = view->height > view->lineno
2385                       ? -view->lineno : -view->height;
2386                 break;
2388         case REQ_MOVE_PAGE_DOWN:
2389                 steps = view->lineno + view->height >= view->lines
2390                       ? view->lines - view->lineno - 1 : view->height;
2391                 break;
2393         case REQ_MOVE_UP:
2394                 steps = -1;
2395                 break;
2397         case REQ_MOVE_DOWN:
2398                 steps = 1;
2399                 break;
2401         default:
2402                 die("request %d not handled in switch", request);
2403         }
2405         if (steps <= 0 && view->lineno == 0) {
2406                 report("Cannot move beyond the first line");
2407                 return;
2409         } else if (steps >= 0 && view->lineno + 1 >= view->lines) {
2410                 report("Cannot move beyond the last line");
2411                 return;
2412         }
2414         /* Move the current line */
2415         view->lineno += steps;
2416         assert(0 <= view->lineno && view->lineno < view->lines);
2418         /* Check whether the view needs to be scrolled */
2419         if (view->lineno < view->offset ||
2420             view->lineno >= view->offset + view->height) {
2421                 scroll_steps = steps;
2422                 if (steps < 0 && -steps > view->offset) {
2423                         scroll_steps = -view->offset;
2425                 } else if (steps > 0) {
2426                         if (view->lineno == view->lines - 1 &&
2427                             view->lines > view->height) {
2428                                 scroll_steps = view->lines - view->offset - 1;
2429                                 if (scroll_steps >= view->height)
2430                                         scroll_steps -= view->height - 1;
2431                         }
2432                 }
2433         }
2435         if (!view_is_displayed(view)) {
2436                 view->offset += scroll_steps;
2437                 assert(0 <= view->offset && view->offset < view->lines);
2438                 view->ops->select(view, &view->line[view->lineno]);
2439                 return;
2440         }
2442         /* Repaint the old "current" line if we be scrolling */
2443         if (ABS(steps) < view->height)
2444                 draw_view_line(view, view->lineno - steps - view->offset);
2446         if (scroll_steps) {
2447                 do_scroll_view(view, scroll_steps);
2448                 return;
2449         }
2451         /* Draw the current line */
2452         draw_view_line(view, view->lineno - view->offset);
2454         wnoutrefresh(view->win);
2455         report("");
2459 /*
2460  * Searching
2461  */
2463 static void search_view(struct view *view, enum request request);
2465 static void
2466 select_view_line(struct view *view, unsigned long lineno)
2468         if (lineno - view->offset >= view->height) {
2469                 view->offset = lineno;
2470                 view->lineno = lineno;
2471                 if (view_is_displayed(view))
2472                         redraw_view(view);
2474         } else {
2475                 unsigned long old_lineno = view->lineno - view->offset;
2477                 view->lineno = lineno;
2478                 if (view_is_displayed(view)) {
2479                         draw_view_line(view, old_lineno);
2480                         draw_view_line(view, view->lineno - view->offset);
2481                         wnoutrefresh(view->win);
2482                 } else {
2483                         view->ops->select(view, &view->line[view->lineno]);
2484                 }
2485         }
2488 static void
2489 find_next(struct view *view, enum request request)
2491         unsigned long lineno = view->lineno;
2492         int direction;
2494         if (!*view->grep) {
2495                 if (!*opt_search)
2496                         report("No previous search");
2497                 else
2498                         search_view(view, request);
2499                 return;
2500         }
2502         switch (request) {
2503         case REQ_SEARCH:
2504         case REQ_FIND_NEXT:
2505                 direction = 1;
2506                 break;
2508         case REQ_SEARCH_BACK:
2509         case REQ_FIND_PREV:
2510                 direction = -1;
2511                 break;
2513         default:
2514                 return;
2515         }
2517         if (request == REQ_FIND_NEXT || request == REQ_FIND_PREV)
2518                 lineno += direction;
2520         /* Note, lineno is unsigned long so will wrap around in which case it
2521          * will become bigger than view->lines. */
2522         for (; lineno < view->lines; lineno += direction) {
2523                 if (view->ops->grep(view, &view->line[lineno])) {
2524                         select_view_line(view, lineno);
2525                         report("Line %ld matches '%s'", lineno + 1, view->grep);
2526                         return;
2527                 }
2528         }
2530         report("No match found for '%s'", view->grep);
2533 static void
2534 search_view(struct view *view, enum request request)
2536         int regex_err;
2538         if (view->regex) {
2539                 regfree(view->regex);
2540                 *view->grep = 0;
2541         } else {
2542                 view->regex = calloc(1, sizeof(*view->regex));
2543                 if (!view->regex)
2544                         return;
2545         }
2547         regex_err = regcomp(view->regex, opt_search, REG_EXTENDED);
2548         if (regex_err != 0) {
2549                 char buf[SIZEOF_STR] = "unknown error";
2551                 regerror(regex_err, view->regex, buf, sizeof(buf));
2552                 report("Search failed: %s", buf);
2553                 return;
2554         }
2556         string_copy(view->grep, opt_search);
2558         find_next(view, request);
2561 /*
2562  * Incremental updating
2563  */
2565 static void
2566 reset_view(struct view *view)
2568         int i;
2570         for (i = 0; i < view->lines; i++)
2571                 free(view->line[i].data);
2572         free(view->line);
2574         view->p_offset = view->offset;
2575         view->p_yoffset = view->yoffset;
2576         view->p_lineno = view->lineno;
2578         view->line = NULL;
2579         view->offset = 0;
2580         view->yoffset = 0;
2581         view->lines  = 0;
2582         view->lineno = 0;
2583         view->line_alloc = 0;
2584         view->vid[0] = 0;
2585         view->update_secs = 0;
2588 static void
2589 free_argv(const char *argv[])
2591         int argc;
2593         for (argc = 0; argv[argc]; argc++)
2594                 free((void *) argv[argc]);
2597 static bool
2598 format_argv(const char *dst_argv[], const char *src_argv[], enum format_flags flags)
2600         char buf[SIZEOF_STR];
2601         int argc;
2602         bool noreplace = flags == FORMAT_NONE;
2604         free_argv(dst_argv);
2606         for (argc = 0; src_argv[argc]; argc++) {
2607                 const char *arg = src_argv[argc];
2608                 size_t bufpos = 0;
2610                 while (arg) {
2611                         char *next = strstr(arg, "%(");
2612                         int len = next - arg;
2613                         const char *value;
2615                         if (!next || noreplace) {
2616                                 if (flags == FORMAT_DASH && !strcmp(arg, "--"))
2617                                         noreplace = TRUE;
2618                                 len = strlen(arg);
2619                                 value = "";
2621                         } else if (!prefixcmp(next, "%(directory)")) {
2622                                 value = opt_path;
2624                         } else if (!prefixcmp(next, "%(file)")) {
2625                                 value = opt_file;
2627                         } else if (!prefixcmp(next, "%(ref)")) {
2628                                 value = *opt_ref ? opt_ref : "HEAD";
2630                         } else if (!prefixcmp(next, "%(head)")) {
2631                                 value = ref_head;
2633                         } else if (!prefixcmp(next, "%(commit)")) {
2634                                 value = ref_commit;
2636                         } else if (!prefixcmp(next, "%(blob)")) {
2637                                 value = ref_blob;
2639                         } else {
2640                                 report("Unknown replacement: `%s`", next);
2641                                 return FALSE;
2642                         }
2644                         if (!string_format_from(buf, &bufpos, "%.*s%s", len, arg, value))
2645                                 return FALSE;
2647                         arg = next && !noreplace ? strchr(next, ')') + 1 : NULL;
2648                 }
2650                 dst_argv[argc] = strdup(buf);
2651                 if (!dst_argv[argc])
2652                         break;
2653         }
2655         dst_argv[argc] = NULL;
2657         return src_argv[argc] == NULL;
2660 static bool
2661 restore_view_position(struct view *view)
2663         if (!view->p_restore || (view->pipe && view->lines <= view->p_lineno))
2664                 return FALSE;
2666         /* Changing the view position cancels the restoring. */
2667         /* FIXME: Changing back to the first line is not detected. */
2668         if (view->offset != 0 || view->lineno != 0) {
2669                 view->p_restore = FALSE;
2670                 return FALSE;
2671         }
2673         if (view->p_lineno >= view->lines) {
2674                 view->p_lineno = view->lines > 0 ? view->lines - 1 : 0;
2675                 if (view->p_offset >= view->p_lineno) {
2676                         unsigned long half = view->height / 2;
2678                         if (view->p_lineno > half)
2679                                 view->p_offset = view->p_lineno - half;
2680                         else
2681                                 view->p_offset = 0;
2682                 }
2683         }
2685         if (view_is_displayed(view) &&
2686             view->offset != view->p_offset &&
2687             view->lineno != view->p_lineno)
2688                 werase(view->win);
2690         view->offset = view->p_offset;
2691         view->yoffset = view->p_yoffset;
2692         view->lineno = view->p_lineno;
2693         view->p_restore = FALSE;
2695         return TRUE;
2698 static void
2699 end_update(struct view *view, bool force)
2701         if (!view->pipe)
2702                 return;
2703         while (!view->ops->read(view, NULL))
2704                 if (!force)
2705                         return;
2706         set_nonblocking_input(FALSE);
2707         if (force)
2708                 kill_io(view->pipe);
2709         done_io(view->pipe);
2710         view->pipe = NULL;
2713 static void
2714 setup_update(struct view *view, const char *vid)
2716         set_nonblocking_input(TRUE);
2717         reset_view(view);
2718         string_copy_rev(view->vid, vid);
2719         view->pipe = &view->io;
2720         view->start_time = time(NULL);
2723 static bool
2724 prepare_update(struct view *view, const char *argv[], const char *dir,
2725                enum format_flags flags)
2727         if (view->pipe)
2728                 end_update(view, TRUE);
2729         return init_io_rd(&view->io, argv, dir, flags);
2732 static bool
2733 prepare_update_file(struct view *view, const char *name)
2735         if (view->pipe)
2736                 end_update(view, TRUE);
2737         return io_open(&view->io, name);
2740 static bool
2741 begin_update(struct view *view, bool refresh)
2743         if (view->pipe)
2744                 end_update(view, TRUE);
2746         if (refresh) {
2747                 if (!start_io(&view->io))
2748                         return FALSE;
2750         } else {
2751                 if (view == VIEW(REQ_VIEW_TREE) && strcmp(view->vid, view->id))
2752                         opt_path[0] = 0;
2754                 if (!run_io_rd(&view->io, view->ops->argv, FORMAT_ALL))
2755                         return FALSE;
2757                 /* Put the current ref_* value to the view title ref
2758                  * member. This is needed by the blob view. Most other
2759                  * views sets it automatically after loading because the
2760                  * first line is a commit line. */
2761                 string_copy_rev(view->ref, view->id);
2762         }
2764         setup_update(view, view->id);
2766         return TRUE;
2769 #define ITEM_CHUNK_SIZE 256
2770 static void *
2771 realloc_items(void *mem, size_t *size, size_t new_size, size_t item_size)
2773         size_t num_chunks = *size / ITEM_CHUNK_SIZE;
2774         size_t num_chunks_new = (new_size + ITEM_CHUNK_SIZE - 1) / ITEM_CHUNK_SIZE;
2776         if (mem == NULL || num_chunks != num_chunks_new) {
2777                 *size = num_chunks_new * ITEM_CHUNK_SIZE;
2778                 mem = realloc(mem, *size * item_size);
2779         }
2781         return mem;
2784 static struct line *
2785 realloc_lines(struct view *view, size_t line_size)
2787         size_t alloc = view->line_alloc;
2788         struct line *tmp = realloc_items(view->line, &alloc, line_size,
2789                                          sizeof(*view->line));
2791         if (!tmp)
2792                 return NULL;
2794         view->line = tmp;
2795         view->line_alloc = alloc;
2796         return view->line;
2799 static bool
2800 update_view(struct view *view)
2802         char out_buffer[BUFSIZ * 2];
2803         char *line;
2804         /* Clear the view and redraw everything since the tree sorting
2805          * might have rearranged things. */
2806         bool redraw = view->lines == 0;
2807         bool can_read = TRUE;
2809         if (!view->pipe)
2810                 return TRUE;
2812         if (!io_can_read(view->pipe)) {
2813                 if (view->lines == 0) {
2814                         time_t secs = time(NULL) - view->start_time;
2816                         if (secs > 1 && secs > view->update_secs) {
2817                                 if (view->update_secs == 0)
2818                                         redraw_view(view);
2819                                 update_view_title(view);
2820                                 view->update_secs = secs;
2821                         }
2822                 }
2823                 return TRUE;
2824         }
2826         for (; (line = io_get(view->pipe, '\n', can_read)); can_read = FALSE) {
2827                 if (opt_iconv != ICONV_NONE) {
2828                         ICONV_CONST char *inbuf = line;
2829                         size_t inlen = strlen(line) + 1;
2831                         char *outbuf = out_buffer;
2832                         size_t outlen = sizeof(out_buffer);
2834                         size_t ret;
2836                         ret = iconv(opt_iconv, &inbuf, &inlen, &outbuf, &outlen);
2837                         if (ret != (size_t) -1)
2838                                 line = out_buffer;
2839                 }
2841                 if (!view->ops->read(view, line)) {
2842                         report("Allocation failure");
2843                         end_update(view, TRUE);
2844                         return FALSE;
2845                 }
2846         }
2848         {
2849                 unsigned long lines = view->lines;
2850                 int digits;
2852                 for (digits = 0; lines; digits++)
2853                         lines /= 10;
2855                 /* Keep the displayed view in sync with line number scaling. */
2856                 if (digits != view->digits) {
2857                         view->digits = digits;
2858                         if (opt_line_number || view == VIEW(REQ_VIEW_BLAME))
2859                                 redraw = TRUE;
2860                 }
2861         }
2863         if (io_error(view->pipe)) {
2864                 report("Failed to read: %s", io_strerror(view->pipe));
2865                 end_update(view, TRUE);
2867         } else if (io_eof(view->pipe)) {
2868                 report("");
2869                 end_update(view, FALSE);
2870         }
2872         if (restore_view_position(view))
2873                 redraw = TRUE;
2875         if (!view_is_displayed(view))
2876                 return TRUE;
2878         if (redraw)
2879                 redraw_view_from(view, 0);
2880         else
2881                 redraw_view_dirty(view);
2883         /* Update the title _after_ the redraw so that if the redraw picks up a
2884          * commit reference in view->ref it'll be available here. */
2885         update_view_title(view);
2886         return TRUE;
2889 static struct line *
2890 add_line_data(struct view *view, void *data, enum line_type type)
2892         struct line *line;
2894         if (!realloc_lines(view, view->lines + 1))
2895                 return NULL;
2897         line = &view->line[view->lines++];
2898         memset(line, 0, sizeof(*line));
2899         line->type = type;
2900         line->data = data;
2901         line->dirty = 1;
2903         return line;
2906 static struct line *
2907 add_line_text(struct view *view, const char *text, enum line_type type)
2909         char *data = text ? strdup(text) : NULL;
2911         return data ? add_line_data(view, data, type) : NULL;
2914 static struct line *
2915 add_line_format(struct view *view, enum line_type type, const char *fmt, ...)
2917         char buf[SIZEOF_STR];
2918         va_list args;
2920         va_start(args, fmt);
2921         if (vsnprintf(buf, sizeof(buf), fmt, args) >= sizeof(buf))
2922                 buf[0] = 0;
2923         va_end(args);
2925         return buf[0] ? add_line_text(view, buf, type) : NULL;
2928 /*
2929  * View opening
2930  */
2932 enum open_flags {
2933         OPEN_DEFAULT = 0,       /* Use default view switching. */
2934         OPEN_SPLIT = 1,         /* Split current view. */
2935         OPEN_BACKGROUNDED = 2,  /* Backgrounded. */
2936         OPEN_RELOAD = 4,        /* Reload view even if it is the current. */
2937         OPEN_NOMAXIMIZE = 8,    /* Do not maximize the current view. */
2938         OPEN_REFRESH = 16,      /* Refresh view using previous command. */
2939         OPEN_PREPARED = 32,     /* Open already prepared command. */
2940 };
2942 static void
2943 open_view(struct view *prev, enum request request, enum open_flags flags)
2945         bool backgrounded = !!(flags & OPEN_BACKGROUNDED);
2946         bool split = !!(flags & OPEN_SPLIT);
2947         bool reload = !!(flags & (OPEN_RELOAD | OPEN_REFRESH | OPEN_PREPARED));
2948         bool nomaximize = !!(flags & (OPEN_NOMAXIMIZE | OPEN_REFRESH));
2949         struct view *view = VIEW(request);
2950         int nviews = displayed_views();
2951         struct view *base_view = display[0];
2953         if (view == prev && nviews == 1 && !reload) {
2954                 report("Already in %s view", view->name);
2955                 return;
2956         }
2958         if (view->git_dir && !opt_git_dir[0]) {
2959                 report("The %s view is disabled in pager view", view->name);
2960                 return;
2961         }
2963         if (split) {
2964                 display[1] = view;
2965                 if (!backgrounded)
2966                         current_view = 1;
2967         } else if (!nomaximize) {
2968                 /* Maximize the current view. */
2969                 memset(display, 0, sizeof(display));
2970                 current_view = 0;
2971                 display[current_view] = view;
2972         }
2974         /* Resize the view when switching between split- and full-screen,
2975          * or when switching between two different full-screen views. */
2976         if (nviews != displayed_views() ||
2977             (nviews == 1 && base_view != display[0]))
2978                 resize_display();
2980         if (view->ops->open) {
2981                 if (view->pipe)
2982                         end_update(view, TRUE);
2983                 if (!view->ops->open(view)) {
2984                         report("Failed to load %s view", view->name);
2985                         return;
2986                 }
2987                 restore_view_position(view);
2989         } else if ((reload || strcmp(view->vid, view->id)) &&
2990                    !begin_update(view, flags & (OPEN_REFRESH | OPEN_PREPARED))) {
2991                 report("Failed to load %s view", view->name);
2992                 return;
2993         }
2995         if (split && prev->lineno - prev->offset >= prev->height) {
2996                 /* Take the title line into account. */
2997                 int lines = prev->lineno - prev->offset - prev->height + 1;
2999                 /* Scroll the view that was split if the current line is
3000                  * outside the new limited view. */
3001                 do_scroll_view(prev, lines);
3002         }
3004         if (prev && view != prev) {
3005                 if (split && !backgrounded) {
3006                         /* "Blur" the previous view. */
3007                         update_view_title(prev);
3008                 }
3010                 view->parent = prev;
3011         }
3013         if (view->pipe && view->lines == 0) {
3014                 /* Clear the old view and let the incremental updating refill
3015                  * the screen. */
3016                 werase(view->win);
3017                 view->p_restore = flags & (OPEN_RELOAD | OPEN_REFRESH);
3018                 report("");
3019         } else if (view_is_displayed(view)) {
3020                 redraw_view(view);
3021                 report("");
3022         }
3024         /* If the view is backgrounded the above calls to report()
3025          * won't redraw the view title. */
3026         if (backgrounded)
3027                 update_view_title(view);
3030 static void
3031 open_external_viewer(const char *argv[], const char *dir)
3033         def_prog_mode();           /* save current tty modes */
3034         endwin();                  /* restore original tty modes */
3035         run_io_fg(argv, dir);
3036         fprintf(stderr, "Press Enter to continue");
3037         getc(opt_tty);
3038         reset_prog_mode();
3039         redraw_display(TRUE);
3042 static void
3043 open_mergetool(const char *file)
3045         const char *mergetool_argv[] = { "git", "mergetool", file, NULL };
3047         open_external_viewer(mergetool_argv, opt_cdup);
3050 static void
3051 open_editor(bool from_root, const char *file)
3053         const char *editor_argv[] = { "vi", file, NULL };
3054         const char *editor;
3056         editor = getenv("GIT_EDITOR");
3057         if (!editor && *opt_editor)
3058                 editor = opt_editor;
3059         if (!editor)
3060                 editor = getenv("VISUAL");
3061         if (!editor)
3062                 editor = getenv("EDITOR");
3063         if (!editor)
3064                 editor = "vi";
3066         editor_argv[0] = editor;
3067         open_external_viewer(editor_argv, from_root ? opt_cdup : NULL);
3070 static void
3071 open_run_request(enum request request)
3073         struct run_request *req = get_run_request(request);
3074         const char *argv[ARRAY_SIZE(req->argv)] = { NULL };
3076         if (!req) {
3077                 report("Unknown run request");
3078                 return;
3079         }
3081         if (format_argv(argv, req->argv, FORMAT_ALL))
3082                 open_external_viewer(argv, NULL);
3083         free_argv(argv);
3086 /*
3087  * User request switch noodle
3088  */
3090 static int
3091 view_driver(struct view *view, enum request request)
3093         int i;
3095         if (request == REQ_NONE) {
3096                 doupdate();
3097                 return TRUE;
3098         }
3100         if (request > REQ_NONE) {
3101                 open_run_request(request);
3102                 /* FIXME: When all views can refresh always do this. */
3103                 if (view == VIEW(REQ_VIEW_STATUS) ||
3104                     view == VIEW(REQ_VIEW_MAIN) ||
3105                     view == VIEW(REQ_VIEW_LOG) ||
3106                     view == VIEW(REQ_VIEW_STAGE))
3107                         request = REQ_REFRESH;
3108                 else
3109                         return TRUE;
3110         }
3112         if (view && view->lines) {
3113                 request = view->ops->request(view, request, &view->line[view->lineno]);
3114                 if (request == REQ_NONE)
3115                         return TRUE;
3116         }
3118         switch (request) {
3119         case REQ_MOVE_UP:
3120         case REQ_MOVE_DOWN:
3121         case REQ_MOVE_PAGE_UP:
3122         case REQ_MOVE_PAGE_DOWN:
3123         case REQ_MOVE_FIRST_LINE:
3124         case REQ_MOVE_LAST_LINE:
3125                 move_view(view, request);
3126                 break;
3128         case REQ_SCROLL_LEFT:
3129         case REQ_SCROLL_RIGHT:
3130         case REQ_SCROLL_LINE_DOWN:
3131         case REQ_SCROLL_LINE_UP:
3132         case REQ_SCROLL_PAGE_DOWN:
3133         case REQ_SCROLL_PAGE_UP:
3134                 scroll_view(view, request);
3135                 break;
3137         case REQ_VIEW_BLAME:
3138                 if (!opt_file[0]) {
3139                         report("No file chosen, press %s to open tree view",
3140                                get_key(REQ_VIEW_TREE));
3141                         break;
3142                 }
3143                 open_view(view, request, OPEN_DEFAULT);
3144                 break;
3146         case REQ_VIEW_BLOB:
3147                 if (!ref_blob[0]) {
3148                         report("No file chosen, press %s to open tree view",
3149                                get_key(REQ_VIEW_TREE));
3150                         break;
3151                 }
3152                 open_view(view, request, OPEN_DEFAULT);
3153                 break;
3155         case REQ_VIEW_PAGER:
3156                 if (!VIEW(REQ_VIEW_PAGER)->pipe && !VIEW(REQ_VIEW_PAGER)->lines) {
3157                         report("No pager content, press %s to run command from prompt",
3158                                get_key(REQ_PROMPT));
3159                         break;
3160                 }
3161                 open_view(view, request, OPEN_DEFAULT);
3162                 break;
3164         case REQ_VIEW_STAGE:
3165                 if (!VIEW(REQ_VIEW_STAGE)->lines) {
3166                         report("No stage content, press %s to open the status view and choose file",
3167                                get_key(REQ_VIEW_STATUS));
3168                         break;
3169                 }
3170                 open_view(view, request, OPEN_DEFAULT);
3171                 break;
3173         case REQ_VIEW_STATUS:
3174                 if (opt_is_inside_work_tree == FALSE) {
3175                         report("The status view requires a working tree");
3176                         break;
3177                 }
3178                 open_view(view, request, OPEN_DEFAULT);
3179                 break;
3181         case REQ_VIEW_MAIN:
3182         case REQ_VIEW_DIFF:
3183         case REQ_VIEW_LOG:
3184         case REQ_VIEW_TREE:
3185         case REQ_VIEW_HELP:
3186                 open_view(view, request, OPEN_DEFAULT);
3187                 break;
3189         case REQ_NEXT:
3190         case REQ_PREVIOUS:
3191                 request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
3193                 if ((view == VIEW(REQ_VIEW_DIFF) &&
3194                      view->parent == VIEW(REQ_VIEW_MAIN)) ||
3195                    (view == VIEW(REQ_VIEW_DIFF) &&
3196                      view->parent == VIEW(REQ_VIEW_BLAME)) ||
3197                    (view == VIEW(REQ_VIEW_STAGE) &&
3198                      view->parent == VIEW(REQ_VIEW_STATUS)) ||
3199                    (view == VIEW(REQ_VIEW_BLOB) &&
3200                      view->parent == VIEW(REQ_VIEW_TREE))) {
3201                         int line;
3203                         view = view->parent;
3204                         line = view->lineno;
3205                         move_view(view, request);
3206                         if (view_is_displayed(view))
3207                                 update_view_title(view);
3208                         if (line != view->lineno)
3209                                 view->ops->request(view, REQ_ENTER,
3210                                                    &view->line[view->lineno]);
3212                 } else {
3213                         move_view(view, request);
3214                 }
3215                 break;
3217         case REQ_VIEW_NEXT:
3218         {
3219                 int nviews = displayed_views();
3220                 int next_view = (current_view + 1) % nviews;
3222                 if (next_view == current_view) {
3223                         report("Only one view is displayed");
3224                         break;
3225                 }
3227                 current_view = next_view;
3228                 /* Blur out the title of the previous view. */
3229                 update_view_title(view);
3230                 report("");
3231                 break;
3232         }
3233         case REQ_REFRESH:
3234                 report("Refreshing is not yet supported for the %s view", view->name);
3235                 break;
3237         case REQ_MAXIMIZE:
3238                 if (displayed_views() == 2)
3239                         open_view(view, VIEW_REQ(view), OPEN_DEFAULT);
3240                 break;
3242         case REQ_TOGGLE_LINENO:
3243                 toggle_view_option(&opt_line_number, "line numbers");
3244                 break;
3246         case REQ_TOGGLE_DATE:
3247                 toggle_view_option(&opt_date, "date display");
3248                 break;
3250         case REQ_TOGGLE_AUTHOR:
3251                 toggle_view_option(&opt_author, "author display");
3252                 break;
3254         case REQ_TOGGLE_REV_GRAPH:
3255                 toggle_view_option(&opt_rev_graph, "revision graph display");
3256                 break;
3258         case REQ_TOGGLE_REFS:
3259                 toggle_view_option(&opt_show_refs, "reference display");
3260                 break;
3262         case REQ_SEARCH:
3263         case REQ_SEARCH_BACK:
3264                 search_view(view, request);
3265                 break;
3267         case REQ_FIND_NEXT:
3268         case REQ_FIND_PREV:
3269                 find_next(view, request);
3270                 break;
3272         case REQ_STOP_LOADING:
3273                 for (i = 0; i < ARRAY_SIZE(views); i++) {
3274                         view = &views[i];
3275                         if (view->pipe)
3276                                 report("Stopped loading the %s view", view->name),
3277                         end_update(view, TRUE);
3278                 }
3279                 break;
3281         case REQ_SHOW_VERSION:
3282                 report("tig-%s (built %s)", TIG_VERSION, __DATE__);
3283                 return TRUE;
3285         case REQ_SCREEN_REDRAW:
3286                 redraw_display(TRUE);
3287                 break;
3289         case REQ_EDIT:
3290                 report("Nothing to edit");
3291                 break;
3293         case REQ_ENTER:
3294                 report("Nothing to enter");
3295                 break;
3297         case REQ_VIEW_CLOSE:
3298                 /* XXX: Mark closed views by letting view->parent point to the
3299                  * view itself. Parents to closed view should never be
3300                  * followed. */
3301                 if (view->parent &&
3302                     view->parent->parent != view->parent) {
3303                         memset(display, 0, sizeof(display));
3304                         current_view = 0;
3305                         display[current_view] = view->parent;
3306                         view->parent = view;
3307                         resize_display();
3308                         redraw_display(FALSE);
3309                         report("");
3310                         break;
3311                 }
3312                 /* Fall-through */
3313         case REQ_QUIT:
3314                 return FALSE;
3316         default:
3317                 report("Unknown key, press 'h' for help");
3318                 return TRUE;
3319         }
3321         return TRUE;
3325 /*
3326  * View backend utilities
3327  */
3329 /* Parse author lines where the name may be empty:
3330  *      author  <email@address.tld> 1138474660 +0100
3331  */
3332 static void
3333 parse_author_line(char *ident, char *author, size_t authorsize, struct tm *tm)
3335         char *nameend = strchr(ident, '<');
3336         char *emailend = strchr(ident, '>');
3338         if (nameend && emailend)
3339                 *nameend = *emailend = 0;
3340         ident = chomp_string(ident);
3341         if (!*ident) {
3342                 if (nameend)
3343                         ident = chomp_string(nameend + 1);
3344                 if (!*ident)
3345                         ident = "Unknown";
3346         }
3348         string_ncopy_do(author, authorsize, ident, strlen(ident));
3350         /* Parse epoch and timezone */
3351         if (emailend && emailend[1] == ' ') {
3352                 char *secs = emailend + 2;
3353                 char *zone = strchr(secs, ' ');
3354                 time_t time = (time_t) atol(secs);
3356                 if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
3357                         long tz;
3359                         zone++;
3360                         tz  = ('0' - zone[1]) * 60 * 60 * 10;
3361                         tz += ('0' - zone[2]) * 60 * 60;
3362                         tz += ('0' - zone[3]) * 60;
3363                         tz += ('0' - zone[4]) * 60;
3365                         if (zone[0] == '-')
3366                                 tz = -tz;
3368                         time -= tz;
3369                 }
3371                 gmtime_r(&time, tm);
3372         }
3375 static enum input_status
3376 select_commit_parent_handler(void *data, char *buf, int c)
3378         size_t parents = *(size_t *) data;
3379         int parent = 0;
3381         if (!isdigit(c))
3382                 return INPUT_SKIP;
3384         if (*buf)
3385                 parent = atoi(buf) * 10;
3386         parent += c - '0';
3388         if (parent > parents)
3389                 return INPUT_SKIP;
3390         return INPUT_OK;
3393 static bool
3394 select_commit_parent(const char *id, char rev[SIZEOF_REV])
3396         char buf[SIZEOF_STR * 4];
3397         const char *revlist_argv[] = {
3398                 "git", "rev-list", "-1", "--parents", id, NULL
3399         };
3400         int parents;
3402         if (!run_io_buf(revlist_argv, buf, sizeof(buf)) ||
3403             !*chomp_string(buf) ||
3404             (parents = (strlen(buf) / 40) - 1) < 0) {
3405                 report("Failed to get parent information");
3406                 return FALSE;
3408         } else if (parents == 0) {
3409                 report("The selected commit has no parents");
3410                 return FALSE;
3411         }
3413         if (parents > 1) {
3414                 char prompt[SIZEOF_STR];
3415                 char *result;
3417                 if (!string_format(prompt, "Which parent? [1..%d] ", parents))
3418                         return FALSE;
3419                 result = prompt_input(prompt, select_commit_parent_handler, &parents);
3420                 if (!result)
3421                         return FALSE;
3422                 parents = atoi(result);
3423         }
3425         string_copy_rev(rev, &buf[41 * parents]);
3426         return TRUE;
3429 /*
3430  * Pager backend
3431  */
3433 static bool
3434 pager_draw(struct view *view, struct line *line, unsigned int lineno)
3436         char text[SIZEOF_STR];
3438         if (opt_line_number && draw_lineno(view, lineno))
3439                 return TRUE;
3441         string_expand(text, sizeof(text), line->data, opt_tab_size);
3442         draw_text(view, line->type, text, TRUE);
3443         return TRUE;
3446 static bool
3447 add_describe_ref(char *buf, size_t *bufpos, const char *commit_id, const char *sep)
3449         const char *describe_argv[] = { "git", "describe", commit_id, NULL };
3450         char refbuf[SIZEOF_STR];
3451         char *ref = NULL;
3453         if (run_io_buf(describe_argv, refbuf, sizeof(refbuf)))
3454                 ref = chomp_string(refbuf);
3456         if (!ref || !*ref)
3457                 return TRUE;
3459         /* This is the only fatal call, since it can "corrupt" the buffer. */
3460         if (!string_nformat(buf, SIZEOF_STR, bufpos, "%s%s", sep, ref))
3461                 return FALSE;
3463         return TRUE;
3466 static void
3467 add_pager_refs(struct view *view, struct line *line)
3469         char buf[SIZEOF_STR];
3470         char *commit_id = (char *)line->data + STRING_SIZE("commit ");
3471         struct ref **refs;
3472         size_t bufpos = 0, refpos = 0;
3473         const char *sep = "Refs: ";
3474         bool is_tag = FALSE;
3476         assert(line->type == LINE_COMMIT);
3478         refs = get_refs(commit_id);
3479         if (!refs) {
3480                 if (view == VIEW(REQ_VIEW_DIFF))
3481                         goto try_add_describe_ref;
3482                 return;
3483         }
3485         do {
3486                 struct ref *ref = refs[refpos];
3487                 const char *fmt = ref->tag    ? "%s[%s]" :
3488                                   ref->remote ? "%s<%s>" : "%s%s";
3490                 if (!string_format_from(buf, &bufpos, fmt, sep, ref->name))
3491                         return;
3492                 sep = ", ";
3493                 if (ref->tag)
3494                         is_tag = TRUE;
3495         } while (refs[refpos++]->next);
3497         if (!is_tag && view == VIEW(REQ_VIEW_DIFF)) {
3498 try_add_describe_ref:
3499                 /* Add <tag>-g<commit_id> "fake" reference. */
3500                 if (!add_describe_ref(buf, &bufpos, commit_id, sep))
3501                         return;
3502         }
3504         if (bufpos == 0)
3505                 return;
3507         add_line_text(view, buf, LINE_PP_REFS);
3510 static bool
3511 pager_read(struct view *view, char *data)
3513         struct line *line;
3515         if (!data)
3516                 return TRUE;
3518         line = add_line_text(view, data, get_line_type(data));
3519         if (!line)
3520                 return FALSE;
3522         if (line->type == LINE_COMMIT &&
3523             (view == VIEW(REQ_VIEW_DIFF) ||
3524              view == VIEW(REQ_VIEW_LOG)))
3525                 add_pager_refs(view, line);
3527         return TRUE;
3530 static enum request
3531 pager_request(struct view *view, enum request request, struct line *line)
3533         int split = 0;
3535         if (request != REQ_ENTER)
3536                 return request;
3538         if (line->type == LINE_COMMIT &&
3539            (view == VIEW(REQ_VIEW_LOG) ||
3540             view == VIEW(REQ_VIEW_PAGER))) {
3541                 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
3542                 split = 1;
3543         }
3545         /* Always scroll the view even if it was split. That way
3546          * you can use Enter to scroll through the log view and
3547          * split open each commit diff. */
3548         scroll_view(view, REQ_SCROLL_LINE_DOWN);
3550         /* FIXME: A minor workaround. Scrolling the view will call report("")
3551          * but if we are scrolling a non-current view this won't properly
3552          * update the view title. */
3553         if (split)
3554                 update_view_title(view);
3556         return REQ_NONE;
3559 static bool
3560 pager_grep(struct view *view, struct line *line)
3562         regmatch_t pmatch;
3563         char *text = line->data;
3565         if (!*text)
3566                 return FALSE;
3568         if (regexec(view->regex, text, 1, &pmatch, 0) == REG_NOMATCH)
3569                 return FALSE;
3571         return TRUE;
3574 static void
3575 pager_select(struct view *view, struct line *line)
3577         if (line->type == LINE_COMMIT) {
3578                 char *text = (char *)line->data + STRING_SIZE("commit ");
3580                 if (view != VIEW(REQ_VIEW_PAGER))
3581                         string_copy_rev(view->ref, text);
3582                 string_copy_rev(ref_commit, text);
3583         }
3586 static struct view_ops pager_ops = {
3587         "line",
3588         NULL,
3589         NULL,
3590         pager_read,
3591         pager_draw,
3592         pager_request,
3593         pager_grep,
3594         pager_select,
3595 };
3597 static const char *log_argv[SIZEOF_ARG] = {
3598         "git", "log", "--no-color", "--cc", "--stat", "-n100", "%(head)", NULL
3599 };
3601 static enum request
3602 log_request(struct view *view, enum request request, struct line *line)
3604         switch (request) {
3605         case REQ_REFRESH:
3606                 load_refs();
3607                 open_view(view, REQ_VIEW_LOG, OPEN_REFRESH);
3608                 return REQ_NONE;
3609         default:
3610                 return pager_request(view, request, line);
3611         }
3614 static struct view_ops log_ops = {
3615         "line",
3616         log_argv,
3617         NULL,
3618         pager_read,
3619         pager_draw,
3620         log_request,
3621         pager_grep,
3622         pager_select,
3623 };
3625 static const char *diff_argv[SIZEOF_ARG] = {
3626         "git", "show", "--pretty=fuller", "--no-color", "--root",
3627                 "--patch-with-stat", "--find-copies-harder", "-C", "%(commit)", NULL
3628 };
3630 static struct view_ops diff_ops = {
3631         "line",
3632         diff_argv,
3633         NULL,
3634         pager_read,
3635         pager_draw,
3636         pager_request,
3637         pager_grep,
3638         pager_select,
3639 };
3641 /*
3642  * Help backend
3643  */
3645 static bool
3646 help_open(struct view *view)
3648         char buf[SIZEOF_STR];
3649         size_t bufpos;
3650         int i;
3652         if (view->lines > 0)
3653                 return TRUE;
3655         add_line_text(view, "Quick reference for tig keybindings:", LINE_DEFAULT);
3657         for (i = 0; i < ARRAY_SIZE(req_info); i++) {
3658                 const char *key;
3660                 if (req_info[i].request == REQ_NONE)
3661                         continue;
3663                 if (!req_info[i].request) {
3664                         add_line_text(view, "", LINE_DEFAULT);
3665                         add_line_text(view, req_info[i].help, LINE_DEFAULT);
3666                         continue;
3667                 }
3669                 key = get_key(req_info[i].request);
3670                 if (!*key)
3671                         key = "(no key defined)";
3673                 for (bufpos = 0; bufpos <= req_info[i].namelen; bufpos++) {
3674                         buf[bufpos] = tolower(req_info[i].name[bufpos]);
3675                         if (buf[bufpos] == '_')
3676                                 buf[bufpos] = '-';
3677                 }
3679                 add_line_format(view, LINE_DEFAULT, "    %-25s %-20s %s",
3680                                 key, buf, req_info[i].help);
3681         }
3683         if (run_requests) {
3684                 add_line_text(view, "", LINE_DEFAULT);
3685                 add_line_text(view, "External commands:", LINE_DEFAULT);
3686         }
3688         for (i = 0; i < run_requests; i++) {
3689                 struct run_request *req = get_run_request(REQ_NONE + i + 1);
3690                 const char *key;
3691                 int argc;
3693                 if (!req)
3694                         continue;
3696                 key = get_key_name(req->key);
3697                 if (!*key)
3698                         key = "(no key defined)";
3700                 for (bufpos = 0, argc = 0; req->argv[argc]; argc++)
3701                         if (!string_format_from(buf, &bufpos, "%s%s",
3702                                                 argc ? " " : "", req->argv[argc]))
3703                                 return REQ_NONE;
3705                 add_line_format(view, LINE_DEFAULT, "    %-10s %-14s `%s`",
3706                                 keymap_table[req->keymap].name, key, buf);
3707         }
3709         return TRUE;
3712 static struct view_ops help_ops = {
3713         "line",
3714         NULL,
3715         help_open,
3716         NULL,
3717         pager_draw,
3718         pager_request,
3719         pager_grep,
3720         pager_select,
3721 };
3724 /*
3725  * Tree backend
3726  */
3728 struct tree_stack_entry {
3729         struct tree_stack_entry *prev;  /* Entry below this in the stack */
3730         unsigned long lineno;           /* Line number to restore */
3731         char *name;                     /* Position of name in opt_path */
3732 };
3734 /* The top of the path stack. */
3735 static struct tree_stack_entry *tree_stack = NULL;
3736 unsigned long tree_lineno = 0;
3738 static void
3739 pop_tree_stack_entry(void)
3741         struct tree_stack_entry *entry = tree_stack;
3743         tree_lineno = entry->lineno;
3744         entry->name[0] = 0;
3745         tree_stack = entry->prev;
3746         free(entry);
3749 static void
3750 push_tree_stack_entry(const char *name, unsigned long lineno)
3752         struct tree_stack_entry *entry = calloc(1, sizeof(*entry));
3753         size_t pathlen = strlen(opt_path);
3755         if (!entry)
3756                 return;
3758         entry->prev = tree_stack;
3759         entry->name = opt_path + pathlen;
3760         tree_stack = entry;
3762         if (!string_format_from(opt_path, &pathlen, "%s/", name)) {
3763                 pop_tree_stack_entry();
3764                 return;
3765         }
3767         /* Move the current line to the first tree entry. */
3768         tree_lineno = 1;
3769         entry->lineno = lineno;
3772 /* Parse output from git-ls-tree(1):
3773  *
3774  * 100644 blob fb0e31ea6cc679b7379631188190e975f5789c26 Makefile
3775  * 100644 blob 5304ca4260aaddaee6498f9630e7d471b8591ea6 README
3776  * 100644 blob f931e1d229c3e185caad4449bf5b66ed72462657 tig.c
3777  * 100644 blob ed09fe897f3c7c9af90bcf80cae92558ea88ae38 web.conf
3778  */
3780 #define SIZEOF_TREE_ATTR \
3781         STRING_SIZE("100644 blob ed09fe897f3c7c9af90bcf80cae92558ea88ae38\t")
3783 #define SIZEOF_TREE_MODE \
3784         STRING_SIZE("100644 ")
3786 #define TREE_ID_OFFSET \
3787         STRING_SIZE("100644 blob ")
3789 struct tree_entry {
3790         char id[SIZEOF_REV];
3791         mode_t mode;
3792         struct tm time;                 /* Date from the author ident. */
3793         char author[75];                /* Author of the commit. */
3794         char name[1];
3795 };
3797 static const char *
3798 tree_path(struct line *line)
3800         return ((struct tree_entry *) line->data)->name;
3804 static int
3805 tree_compare_entry(struct line *line1, struct line *line2)
3807         if (line1->type != line2->type)
3808                 return line1->type == LINE_TREE_DIR ? -1 : 1;
3809         return strcmp(tree_path(line1), tree_path(line2));
3812 static struct line *
3813 tree_entry(struct view *view, enum line_type type, const char *path,
3814            const char *mode, const char *id)
3816         struct tree_entry *entry = calloc(1, sizeof(*entry) + strlen(path));
3817         struct line *line = entry ? add_line_data(view, entry, type) : NULL;
3819         if (!entry || !line) {
3820                 free(entry);
3821                 return NULL;
3822         }
3824         strncpy(entry->name, path, strlen(path));
3825         if (mode)
3826                 entry->mode = strtoul(mode, NULL, 8);
3827         if (id)
3828                 string_copy_rev(entry->id, id);
3830         return line;
3833 static bool
3834 tree_read_date(struct view *view, char *text, bool *read_date)
3836         static char author_name[SIZEOF_STR];
3837         static struct tm author_time;
3839         if (!text && *read_date) {
3840                 *read_date = FALSE;
3841                 return TRUE;
3843         } else if (!text) {
3844                 char *path = *opt_path ? opt_path : ".";
3845                 /* Find next entry to process */
3846                 const char *log_file[] = {
3847                         "git", "log", "--no-color", "--pretty=raw",
3848                                 "--cc", "--raw", view->id, "--", path, NULL
3849                 };
3850                 struct io io = {};
3852                 if (!run_io_rd(&io, log_file, FORMAT_NONE)) {
3853                         report("Failed to load tree data");
3854                         return TRUE;
3855                 }
3857                 done_io(view->pipe);
3858                 view->io = io;
3859                 *read_date = TRUE;
3860                 return FALSE;
3862         } else if (*text == 'a' && get_line_type(text) == LINE_AUTHOR) {
3863                 parse_author_line(text + STRING_SIZE("author "),
3864                                   author_name, sizeof(author_name), &author_time);
3866         } else if (*text == ':') {
3867                 char *pos;
3868                 size_t annotated = 1;
3869                 size_t i;
3871                 pos = strchr(text, '\t');
3872                 if (!pos)
3873                         return TRUE;
3874                 text = pos + 1;
3875                 if (*opt_prefix && !strncmp(text, opt_prefix, strlen(opt_prefix)))
3876                         text += strlen(opt_prefix);
3877                 if (*opt_path && !strncmp(text, opt_path, strlen(opt_path)))
3878                         text += strlen(opt_path);
3879                 pos = strchr(text, '/');
3880                 if (pos)
3881                         *pos = 0;
3883                 for (i = 1; i < view->lines; i++) {
3884                         struct line *line = &view->line[i];
3885                         struct tree_entry *entry = line->data;
3887                         annotated += !!*entry->author;
3888                         if (*entry->author || strcmp(entry->name, text))
3889                                 continue;
3891                         string_copy(entry->author, author_name);
3892                         memcpy(&entry->time, &author_time, sizeof(entry->time));
3893                         line->dirty = 1;
3894                         break;
3895                 }
3897                 if (annotated == view->lines)
3898                         kill_io(view->pipe);
3899         }
3900         return TRUE;
3903 static bool
3904 tree_read(struct view *view, char *text)
3906         static bool read_date = FALSE;
3907         struct tree_entry *data;
3908         struct line *entry, *line;
3909         enum line_type type;
3910         size_t textlen = text ? strlen(text) : 0;
3911         char *path = text + SIZEOF_TREE_ATTR;
3913         if (read_date || !text)
3914                 return tree_read_date(view, text, &read_date);
3916         if (textlen <= SIZEOF_TREE_ATTR)
3917                 return FALSE;
3918         if (view->lines == 0 &&
3919             !tree_entry(view, LINE_TREE_PARENT, opt_path, NULL, NULL))
3920                 return FALSE;
3922         /* Strip the path part ... */
3923         if (*opt_path) {
3924                 size_t pathlen = textlen - SIZEOF_TREE_ATTR;
3925                 size_t striplen = strlen(opt_path);
3927                 if (pathlen > striplen)
3928                         memmove(path, path + striplen,
3929                                 pathlen - striplen + 1);
3931                 /* Insert "link" to parent directory. */
3932                 if (view->lines == 1 &&
3933                     !tree_entry(view, LINE_TREE_DIR, "..", "040000", view->ref))
3934                         return FALSE;
3935         }
3937         type = text[SIZEOF_TREE_MODE] == 't' ? LINE_TREE_DIR : LINE_TREE_FILE;
3938         entry = tree_entry(view, type, path, text, text + TREE_ID_OFFSET);
3939         if (!entry)
3940                 return FALSE;
3941         data = entry->data;
3943         /* Skip "Directory ..." and ".." line. */
3944         for (line = &view->line[1 + !!*opt_path]; line < entry; line++) {
3945                 if (tree_compare_entry(line, entry) <= 0)
3946                         continue;
3948                 memmove(line + 1, line, (entry - line) * sizeof(*entry));
3950                 line->data = data;
3951                 line->type = type;
3952                 for (; line <= entry; line++)
3953                         line->dirty = line->cleareol = 1;
3954                 return TRUE;
3955         }
3957         if (tree_lineno > view->lineno) {
3958                 view->lineno = tree_lineno;
3959                 tree_lineno = 0;
3960         }
3962         return TRUE;
3965 static bool
3966 tree_draw(struct view *view, struct line *line, unsigned int lineno)
3968         struct tree_entry *entry = line->data;
3970         if (line->type == LINE_TREE_PARENT) {
3971                 if (draw_text(view, line->type, "Directory path /", TRUE))
3972                         return TRUE;
3973         } else {
3974                 char mode[11] = "-r--r--r--";
3976                 if (S_ISDIR(entry->mode)) {
3977                         mode[3] = mode[6] = mode[9] = 'x';
3978                         mode[0] = 'd';
3979                 }
3980                 if (S_ISLNK(entry->mode))
3981                         mode[0] = 'l';
3982                 if (entry->mode & S_IWUSR)
3983                         mode[2] = 'w';
3984                 if (entry->mode & S_IXUSR)
3985                         mode[3] = 'x';
3986                 if (entry->mode & S_IXGRP)
3987                         mode[6] = 'x';
3988                 if (entry->mode & S_IXOTH)
3989                         mode[9] = 'x';
3990                 if (draw_field(view, LINE_TREE_MODE, mode, 11, TRUE))
3991                         return TRUE;
3993                 if (opt_author && draw_author(view, entry->author))
3994                         return TRUE;
3996                 if (opt_date && draw_date(view, *entry->author ? &entry->time : NULL))
3997                         return TRUE;
3998         }
3999         if (draw_text(view, line->type, entry->name, TRUE))
4000                 return TRUE;
4001         return TRUE;
4004 static void
4005 open_blob_editor()
4007         char file[SIZEOF_STR] = "/tmp/tigblob.XXXXXX";
4008         int fd = mkstemp(file);
4010         if (fd == -1)
4011                 report("Failed to create temporary file");
4012         else if (!run_io_append(blob_ops.argv, FORMAT_ALL, fd))
4013                 report("Failed to save blob data to file");
4014         else
4015                 open_editor(FALSE, file);
4016         if (fd != -1)
4017                 unlink(file);
4020 static enum request
4021 tree_request(struct view *view, enum request request, struct line *line)
4023         enum open_flags flags;
4025         switch (request) {
4026         case REQ_VIEW_BLAME:
4027                 if (line->type != LINE_TREE_FILE) {
4028                         report("Blame only supported for files");
4029                         return REQ_NONE;
4030                 }
4032                 string_copy(opt_ref, view->vid);
4033                 return request;
4035         case REQ_EDIT:
4036                 if (line->type != LINE_TREE_FILE) {
4037                         report("Edit only supported for files");
4038                 } else if (!is_head_commit(view->vid)) {
4039                         open_blob_editor();
4040                 } else {
4041                         open_editor(TRUE, opt_file);
4042                 }
4043                 return REQ_NONE;
4045         case REQ_PARENT:
4046                 if (!*opt_path) {
4047                         /* quit view if at top of tree */
4048                         return REQ_VIEW_CLOSE;
4049                 }
4050                 /* fake 'cd  ..' */
4051                 line = &view->line[1];
4052                 break;
4054         case REQ_ENTER:
4055                 break;
4057         default:
4058                 return request;
4059         }
4061         /* Cleanup the stack if the tree view is at a different tree. */
4062         while (!*opt_path && tree_stack)
4063                 pop_tree_stack_entry();
4065         switch (line->type) {
4066         case LINE_TREE_DIR:
4067                 /* Depending on whether it is a subdir or parent (updir?) link
4068                  * mangle the path buffer. */
4069                 if (line == &view->line[1] && *opt_path) {
4070                         pop_tree_stack_entry();
4072                 } else {
4073                         const char *basename = tree_path(line);
4075                         push_tree_stack_entry(basename, view->lineno);
4076                 }
4078                 /* Trees and subtrees share the same ID, so they are not not
4079                  * unique like blobs. */
4080                 flags = OPEN_RELOAD;
4081                 request = REQ_VIEW_TREE;
4082                 break;
4084         case LINE_TREE_FILE:
4085                 flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
4086                 request = REQ_VIEW_BLOB;
4087                 break;
4089         default:
4090                 return REQ_NONE;
4091         }
4093         open_view(view, request, flags);
4094         if (request == REQ_VIEW_TREE)
4095                 view->lineno = tree_lineno;
4097         return REQ_NONE;
4100 static void
4101 tree_select(struct view *view, struct line *line)
4103         struct tree_entry *entry = line->data;
4105         if (line->type == LINE_TREE_FILE) {
4106                 string_copy_rev(ref_blob, entry->id);
4107                 string_format(opt_file, "%s%s", opt_path, tree_path(line));
4109         } else if (line->type != LINE_TREE_DIR) {
4110                 return;
4111         }
4113         string_copy_rev(view->ref, entry->id);
4116 static const char *tree_argv[SIZEOF_ARG] = {
4117         "git", "ls-tree", "%(commit)", "%(directory)", NULL
4118 };
4120 static struct view_ops tree_ops = {
4121         "file",
4122         tree_argv,
4123         NULL,
4124         tree_read,
4125         tree_draw,
4126         tree_request,
4127         pager_grep,
4128         tree_select,
4129 };
4131 static bool
4132 blob_read(struct view *view, char *line)
4134         if (!line)
4135                 return TRUE;
4136         return add_line_text(view, line, LINE_DEFAULT) != NULL;
4139 static enum request
4140 blob_request(struct view *view, enum request request, struct line *line)
4142         switch (request) {
4143         case REQ_EDIT:
4144                 open_blob_editor();
4145                 return REQ_NONE;
4146         default:
4147                 return pager_request(view, request, line);
4148         }
4151 static const char *blob_argv[SIZEOF_ARG] = {
4152         "git", "cat-file", "blob", "%(blob)", NULL
4153 };
4155 static struct view_ops blob_ops = {
4156         "line",
4157         blob_argv,
4158         NULL,
4159         blob_read,
4160         pager_draw,
4161         blob_request,
4162         pager_grep,
4163         pager_select,
4164 };
4166 /*
4167  * Blame backend
4168  *
4169  * Loading the blame view is a two phase job:
4170  *
4171  *  1. File content is read either using opt_file from the
4172  *     filesystem or using git-cat-file.
4173  *  2. Then blame information is incrementally added by
4174  *     reading output from git-blame.
4175  */
4177 static const char *blame_head_argv[] = {
4178         "git", "blame", "--incremental", "--", "%(file)", NULL
4179 };
4181 static const char *blame_ref_argv[] = {
4182         "git", "blame", "--incremental", "%(ref)", "--", "%(file)", NULL
4183 };
4185 static const char *blame_cat_file_argv[] = {
4186         "git", "cat-file", "blob", "%(ref):%(file)", NULL
4187 };
4189 struct blame_commit {
4190         char id[SIZEOF_REV];            /* SHA1 ID. */
4191         char title[128];                /* First line of the commit message. */
4192         char author[75];                /* Author of the commit. */
4193         struct tm time;                 /* Date from the author ident. */
4194         char filename[128];             /* Name of file. */
4195         bool has_previous;              /* Was a "previous" line detected. */
4196 };
4198 struct blame {
4199         struct blame_commit *commit;
4200         char text[1];
4201 };
4203 static bool
4204 blame_open(struct view *view)
4206         if (*opt_ref || !io_open(&view->io, opt_file)) {
4207                 if (!run_io_rd(&view->io, blame_cat_file_argv, FORMAT_ALL))
4208                         return FALSE;
4209         }
4211         setup_update(view, opt_file);
4212         string_format(view->ref, "%s ...", opt_file);
4214         return TRUE;
4217 static struct blame_commit *
4218 get_blame_commit(struct view *view, const char *id)
4220         size_t i;
4222         for (i = 0; i < view->lines; i++) {
4223                 struct blame *blame = view->line[i].data;
4225                 if (!blame->commit)
4226                         continue;
4228                 if (!strncmp(blame->commit->id, id, SIZEOF_REV - 1))
4229                         return blame->commit;
4230         }
4232         {
4233                 struct blame_commit *commit = calloc(1, sizeof(*commit));
4235                 if (commit)
4236                         string_ncopy(commit->id, id, SIZEOF_REV);
4237                 return commit;
4238         }
4241 static bool
4242 parse_number(const char **posref, size_t *number, size_t min, size_t max)
4244         const char *pos = *posref;
4246         *posref = NULL;
4247         pos = strchr(pos + 1, ' ');
4248         if (!pos || !isdigit(pos[1]))
4249                 return FALSE;
4250         *number = atoi(pos + 1);
4251         if (*number < min || *number > max)
4252                 return FALSE;
4254         *posref = pos;
4255         return TRUE;
4258 static struct blame_commit *
4259 parse_blame_commit(struct view *view, const char *text, int *blamed)
4261         struct blame_commit *commit;
4262         struct blame *blame;
4263         const char *pos = text + SIZEOF_REV - 1;
4264         size_t lineno;
4265         size_t group;
4267         if (strlen(text) <= SIZEOF_REV || *pos != ' ')
4268                 return NULL;
4270         if (!parse_number(&pos, &lineno, 1, view->lines) ||
4271             !parse_number(&pos, &group, 1, view->lines - lineno + 1))
4272                 return NULL;
4274         commit = get_blame_commit(view, text);
4275         if (!commit)
4276                 return NULL;
4278         *blamed += group;
4279         while (group--) {
4280                 struct line *line = &view->line[lineno + group - 1];
4282                 blame = line->data;
4283                 blame->commit = commit;
4284                 line->dirty = 1;
4285         }
4287         return commit;
4290 static bool
4291 blame_read_file(struct view *view, const char *line, bool *read_file)
4293         if (!line) {
4294                 const char **argv = *opt_ref ? blame_ref_argv : blame_head_argv;
4295                 struct io io = {};
4297                 if (view->lines == 0 && !view->parent)
4298                         die("No blame exist for %s", view->vid);
4300                 if (view->lines == 0 || !run_io_rd(&io, argv, FORMAT_ALL)) {
4301                         report("Failed to load blame data");
4302                         return TRUE;
4303                 }
4305                 done_io(view->pipe);
4306                 view->io = io;
4307                 *read_file = FALSE;
4308                 return FALSE;
4310         } else {
4311                 size_t linelen = string_expand_length(line, opt_tab_size);
4312                 struct blame *blame = malloc(sizeof(*blame) + linelen);
4314                 if (!blame)
4315                         return FALSE;
4317                 blame->commit = NULL;
4318                 string_expand(blame->text, linelen + 1, line, opt_tab_size);
4319                 return add_line_data(view, blame, LINE_BLAME_ID) != NULL;
4320         }
4323 static bool
4324 match_blame_header(const char *name, char **line)
4326         size_t namelen = strlen(name);
4327         bool matched = !strncmp(name, *line, namelen);
4329         if (matched)
4330                 *line += namelen;
4332         return matched;
4335 static bool
4336 blame_read(struct view *view, char *line)
4338         static struct blame_commit *commit = NULL;
4339         static int blamed = 0;
4340         static time_t author_time;
4341         static bool read_file = TRUE;
4343         if (read_file)
4344                 return blame_read_file(view, line, &read_file);
4346         if (!line) {
4347                 /* Reset all! */
4348                 commit = NULL;
4349                 blamed = 0;
4350                 read_file = TRUE;
4351                 string_format(view->ref, "%s", view->vid);
4352                 if (view_is_displayed(view)) {
4353                         update_view_title(view);
4354                         redraw_view_from(view, 0);
4355                 }
4356                 return TRUE;
4357         }
4359         if (!commit) {
4360                 commit = parse_blame_commit(view, line, &blamed);
4361                 string_format(view->ref, "%s %2d%%", view->vid,
4362                               view->lines ? blamed * 100 / view->lines : 0);
4364         } else if (match_blame_header("author ", &line)) {
4365                 string_ncopy(commit->author, line, strlen(line));
4367         } else if (match_blame_header("author-time ", &line)) {
4368                 author_time = (time_t) atol(line);
4370         } else if (match_blame_header("author-tz ", &line)) {
4371                 long tz;
4373                 tz  = ('0' - line[1]) * 60 * 60 * 10;
4374                 tz += ('0' - line[2]) * 60 * 60;
4375                 tz += ('0' - line[3]) * 60;
4376                 tz += ('0' - line[4]) * 60;
4378                 if (line[0] == '-')
4379                         tz = -tz;
4381                 author_time -= tz;
4382                 gmtime_r(&author_time, &commit->time);
4384         } else if (match_blame_header("summary ", &line)) {
4385                 string_ncopy(commit->title, line, strlen(line));
4387         } else if (match_blame_header("previous ", &line)) {
4388                 commit->has_previous = TRUE;
4390         } else if (match_blame_header("filename ", &line)) {
4391                 string_ncopy(commit->filename, line, strlen(line));
4392                 commit = NULL;
4393         }
4395         return TRUE;
4398 static bool
4399 blame_draw(struct view *view, struct line *line, unsigned int lineno)
4401         struct blame *blame = line->data;
4402         struct tm *time = NULL;
4403         const char *id = NULL, *author = NULL;
4405         if (blame->commit && *blame->commit->filename) {
4406                 id = blame->commit->id;
4407                 author = blame->commit->author;
4408                 time = &blame->commit->time;
4409         }
4411         if (opt_date && draw_date(view, time))
4412                 return TRUE;
4414         if (opt_author && draw_author(view, author))
4415                 return TRUE;
4417         if (draw_field(view, LINE_BLAME_ID, id, ID_COLS, FALSE))
4418                 return TRUE;
4420         if (draw_lineno(view, lineno))
4421                 return TRUE;
4423         draw_text(view, LINE_DEFAULT, blame->text, TRUE);
4424         return TRUE;
4427 static bool
4428 check_blame_commit(struct blame *blame)
4430         if (!blame->commit)
4431                 report("Commit data not loaded yet");
4432         else if (!strcmp(blame->commit->id, NULL_ID))
4433                 report("No commit exist for the selected line");
4434         else
4435                 return TRUE;
4436         return FALSE;
4439 static enum request
4440 blame_request(struct view *view, enum request request, struct line *line)
4442         enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
4443         struct blame *blame = line->data;
4445         switch (request) {
4446         case REQ_VIEW_BLAME:
4447                 if (check_blame_commit(blame)) {
4448                         string_copy(opt_ref, blame->commit->id);
4449                         open_view(view, REQ_VIEW_BLAME, OPEN_REFRESH);
4450                 }
4451                 break;
4453         case REQ_PARENT:
4454                 if (check_blame_commit(blame) &&
4455                     select_commit_parent(blame->commit->id, opt_ref))
4456                         open_view(view, REQ_VIEW_BLAME, OPEN_REFRESH);
4457                 break;
4459         case REQ_ENTER:
4460                 if (!blame->commit) {
4461                         report("No commit loaded yet");
4462                         break;
4463                 }
4465                 if (view_is_displayed(VIEW(REQ_VIEW_DIFF)) &&
4466                     !strcmp(blame->commit->id, VIEW(REQ_VIEW_DIFF)->ref))
4467                         break;
4469                 if (!strcmp(blame->commit->id, NULL_ID)) {
4470                         struct view *diff = VIEW(REQ_VIEW_DIFF);
4471                         const char *diff_index_argv[] = {
4472                                 "git", "diff-index", "--root", "--patch-with-stat",
4473                                         "-C", "-M", "HEAD", "--", view->vid, NULL
4474                         };
4476                         if (!blame->commit->has_previous) {
4477                                 diff_index_argv[1] = "diff";
4478                                 diff_index_argv[2] = "--no-color";
4479                                 diff_index_argv[6] = "--";
4480                                 diff_index_argv[7] = "/dev/null";
4481                         }
4483                         if (!prepare_update(diff, diff_index_argv, NULL, FORMAT_DASH)) {
4484                                 report("Failed to allocate diff command");
4485                                 break;
4486                         }
4487                         flags |= OPEN_PREPARED;
4488                 }
4490                 open_view(view, REQ_VIEW_DIFF, flags);
4491                 if (VIEW(REQ_VIEW_DIFF)->pipe && !strcmp(blame->commit->id, NULL_ID))
4492                         string_copy_rev(VIEW(REQ_VIEW_DIFF)->ref, NULL_ID);
4493                 break;
4495         default:
4496                 return request;
4497         }
4499         return REQ_NONE;
4502 static bool
4503 blame_grep(struct view *view, struct line *line)
4505         struct blame *blame = line->data;
4506         struct blame_commit *commit = blame->commit;
4507         regmatch_t pmatch;
4509 #define MATCH(text, on)                                                 \
4510         (on && *text && regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
4512         if (commit) {
4513                 char buf[DATE_COLS + 1];
4515                 if (MATCH(commit->title, 1) ||
4516                     MATCH(commit->author, opt_author) ||
4517                     MATCH(commit->id, opt_date))
4518                         return TRUE;
4520                 if (strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time) &&
4521                     MATCH(buf, 1))
4522                         return TRUE;
4523         }
4525         return MATCH(blame->text, 1);
4527 #undef MATCH
4530 static void
4531 blame_select(struct view *view, struct line *line)
4533         struct blame *blame = line->data;
4534         struct blame_commit *commit = blame->commit;
4536         if (!commit)
4537                 return;
4539         if (!strcmp(commit->id, NULL_ID))
4540                 string_ncopy(ref_commit, "HEAD", 4);
4541         else
4542                 string_copy_rev(ref_commit, commit->id);
4545 static struct view_ops blame_ops = {
4546         "line",
4547         NULL,
4548         blame_open,
4549         blame_read,
4550         blame_draw,
4551         blame_request,
4552         blame_grep,
4553         blame_select,
4554 };
4556 /*
4557  * Status backend
4558  */
4560 struct status {
4561         char status;
4562         struct {
4563                 mode_t mode;
4564                 char rev[SIZEOF_REV];
4565                 char name[SIZEOF_STR];
4566         } old;
4567         struct {
4568                 mode_t mode;
4569                 char rev[SIZEOF_REV];
4570                 char name[SIZEOF_STR];
4571         } new;
4572 };
4574 static char status_onbranch[SIZEOF_STR];
4575 static struct status stage_status;
4576 static enum line_type stage_line_type;
4577 static size_t stage_chunks;
4578 static int *stage_chunk;
4580 /* This should work even for the "On branch" line. */
4581 static inline bool
4582 status_has_none(struct view *view, struct line *line)
4584         return line < view->line + view->lines && !line[1].data;
4587 /* Get fields from the diff line:
4588  * :100644 100644 06a5d6ae9eca55be2e0e585a152e6b1336f2b20e 0000000000000000000000000000000000000000 M
4589  */
4590 static inline bool
4591 status_get_diff(struct status *file, const char *buf, size_t bufsize)
4593         const char *old_mode = buf +  1;
4594         const char *new_mode = buf +  8;
4595         const char *old_rev  = buf + 15;
4596         const char *new_rev  = buf + 56;
4597         const char *status   = buf + 97;
4599         if (bufsize < 98 ||
4600             old_mode[-1] != ':' ||
4601             new_mode[-1] != ' ' ||
4602             old_rev[-1]  != ' ' ||
4603             new_rev[-1]  != ' ' ||
4604             status[-1]   != ' ')
4605                 return FALSE;
4607         file->status = *status;
4609         string_copy_rev(file->old.rev, old_rev);
4610         string_copy_rev(file->new.rev, new_rev);
4612         file->old.mode = strtoul(old_mode, NULL, 8);
4613         file->new.mode = strtoul(new_mode, NULL, 8);
4615         file->old.name[0] = file->new.name[0] = 0;
4617         return TRUE;
4620 static bool
4621 status_run(struct view *view, const char *argv[], char status, enum line_type type)
4623         struct status *unmerged = NULL;
4624         char *buf;
4625         struct io io = {};
4627         if (!run_io(&io, argv, NULL, IO_RD))
4628                 return FALSE;
4630         add_line_data(view, NULL, type);
4632         while ((buf = io_get(&io, 0, TRUE))) {
4633                 struct status *file = unmerged;
4635                 if (!file) {
4636                         file = calloc(1, sizeof(*file));
4637                         if (!file || !add_line_data(view, file, type))
4638                                 goto error_out;
4639                 }
4641                 /* Parse diff info part. */
4642                 if (status) {
4643                         file->status = status;
4644                         if (status == 'A')
4645                                 string_copy(file->old.rev, NULL_ID);
4647                 } else if (!file->status || file == unmerged) {
4648                         if (!status_get_diff(file, buf, strlen(buf)))
4649                                 goto error_out;
4651                         buf = io_get(&io, 0, TRUE);
4652                         if (!buf)
4653                                 break;
4655                         /* Collapse all 'M'odified entries that follow a
4656                          * associated 'U'nmerged entry. */
4657                         if (unmerged == file) {
4658                                 unmerged->status = 'U';
4659                                 unmerged = NULL;
4660                         } else if (file->status == 'U') {
4661                                 unmerged = file;
4662                         }
4663                 }
4665                 /* Grab the old name for rename/copy. */
4666                 if (!*file->old.name &&
4667                     (file->status == 'R' || file->status == 'C')) {
4668                         string_ncopy(file->old.name, buf, strlen(buf));
4670                         buf = io_get(&io, 0, TRUE);
4671                         if (!buf)
4672                                 break;
4673                 }
4675                 /* git-ls-files just delivers a NUL separated list of
4676                  * file names similar to the second half of the
4677                  * git-diff-* output. */
4678                 string_ncopy(file->new.name, buf, strlen(buf));
4679                 if (!*file->old.name)
4680                         string_copy(file->old.name, file->new.name);
4681                 file = NULL;
4682         }
4684         if (io_error(&io)) {
4685 error_out:
4686                 done_io(&io);
4687                 return FALSE;
4688         }
4690         if (!view->line[view->lines - 1].data)
4691                 add_line_data(view, NULL, LINE_STAT_NONE);
4693         done_io(&io);
4694         return TRUE;
4697 /* Don't show unmerged entries in the staged section. */
4698 static const char *status_diff_index_argv[] = {
4699         "git", "diff-index", "-z", "--diff-filter=ACDMRTXB",
4700                              "--cached", "-M", "HEAD", NULL
4701 };
4703 static const char *status_diff_files_argv[] = {
4704         "git", "diff-files", "-z", NULL
4705 };
4707 static const char *status_list_other_argv[] = {
4708         "git", "ls-files", "-z", "--others", "--exclude-standard", NULL
4709 };
4711 static const char *status_list_no_head_argv[] = {
4712         "git", "ls-files", "-z", "--cached", "--exclude-standard", NULL
4713 };
4715 static const char *update_index_argv[] = {
4716         "git", "update-index", "-q", "--unmerged", "--refresh", NULL
4717 };
4719 /* Restore the previous line number to stay in the context or select a
4720  * line with something that can be updated. */
4721 static void
4722 status_restore(struct view *view)
4724         if (view->p_lineno >= view->lines)
4725                 view->p_lineno = view->lines - 1;
4726         while (view->p_lineno < view->lines && !view->line[view->p_lineno].data)
4727                 view->p_lineno++;
4728         while (view->p_lineno > 0 && !view->line[view->p_lineno].data)
4729                 view->p_lineno--;
4731         /* If the above fails, always skip the "On branch" line. */
4732         if (view->p_lineno < view->lines)
4733                 view->lineno = view->p_lineno;
4734         else
4735                 view->lineno = 1;
4737         if (view->lineno < view->offset)
4738                 view->offset = view->lineno;
4739         else if (view->offset + view->height <= view->lineno)
4740                 view->offset = view->lineno - view->height + 1;
4742         view->p_restore = FALSE;
4745 /* First parse staged info using git-diff-index(1), then parse unstaged
4746  * info using git-diff-files(1), and finally untracked files using
4747  * git-ls-files(1). */
4748 static bool
4749 status_open(struct view *view)
4751         reset_view(view);
4753         add_line_data(view, NULL, LINE_STAT_HEAD);
4754         if (is_initial_commit())
4755                 string_copy(status_onbranch, "Initial commit");
4756         else if (!*opt_head)
4757                 string_copy(status_onbranch, "Not currently on any branch");
4758         else if (!string_format(status_onbranch, "On branch %s", opt_head))
4759                 return FALSE;
4761         run_io_bg(update_index_argv);
4763         if (is_initial_commit()) {
4764                 if (!status_run(view, status_list_no_head_argv, 'A', LINE_STAT_STAGED))
4765                         return FALSE;
4766         } else if (!status_run(view, status_diff_index_argv, 0, LINE_STAT_STAGED)) {
4767                 return FALSE;
4768         }
4770         if (!status_run(view, status_diff_files_argv, 0, LINE_STAT_UNSTAGED) ||
4771             !status_run(view, status_list_other_argv, '?', LINE_STAT_UNTRACKED))
4772                 return FALSE;
4774         /* Restore the exact position or use the specialized restore
4775          * mode? */
4776         if (!view->p_restore)
4777                 status_restore(view);
4778         return TRUE;
4781 static bool
4782 status_draw(struct view *view, struct line *line, unsigned int lineno)
4784         struct status *status = line->data;
4785         enum line_type type;
4786         const char *text;
4788         if (!status) {
4789                 switch (line->type) {
4790                 case LINE_STAT_STAGED:
4791                         type = LINE_STAT_SECTION;
4792                         text = "Changes to be committed:";
4793                         break;
4795                 case LINE_STAT_UNSTAGED:
4796                         type = LINE_STAT_SECTION;
4797                         text = "Changed but not updated:";
4798                         break;
4800                 case LINE_STAT_UNTRACKED:
4801                         type = LINE_STAT_SECTION;
4802                         text = "Untracked files:";
4803                         break;
4805                 case LINE_STAT_NONE:
4806                         type = LINE_DEFAULT;
4807                         text = "  (no files)";
4808                         break;
4810                 case LINE_STAT_HEAD:
4811                         type = LINE_STAT_HEAD;
4812                         text = status_onbranch;
4813                         break;
4815                 default:
4816                         return FALSE;
4817                 }
4818         } else {
4819                 static char buf[] = { '?', ' ', ' ', ' ', 0 };
4821                 buf[0] = status->status;
4822                 if (draw_text(view, line->type, buf, TRUE))
4823                         return TRUE;
4824                 type = LINE_DEFAULT;
4825                 text = status->new.name;
4826         }
4828         draw_text(view, type, text, TRUE);
4829         return TRUE;
4832 static enum request
4833 status_enter(struct view *view, struct line *line)
4835         struct status *status = line->data;
4836         const char *oldpath = status ? status->old.name : NULL;
4837         /* Diffs for unmerged entries are empty when passing the new
4838          * path, so leave it empty. */
4839         const char *newpath = status && status->status != 'U' ? status->new.name : NULL;
4840         const char *info;
4841         enum open_flags split;
4842         struct view *stage = VIEW(REQ_VIEW_STAGE);
4844         if (line->type == LINE_STAT_NONE ||
4845             (!status && line[1].type == LINE_STAT_NONE)) {
4846                 report("No file to diff");
4847                 return REQ_NONE;
4848         }
4850         switch (line->type) {
4851         case LINE_STAT_STAGED:
4852                 if (is_initial_commit()) {
4853                         const char *no_head_diff_argv[] = {
4854                                 "git", "diff", "--no-color", "--patch-with-stat",
4855                                         "--", "/dev/null", newpath, NULL
4856                         };
4858                         if (!prepare_update(stage, no_head_diff_argv, opt_cdup, FORMAT_DASH))
4859                                 return REQ_QUIT;
4860                 } else {
4861                         const char *index_show_argv[] = {
4862                                 "git", "diff-index", "--root", "--patch-with-stat",
4863                                         "-C", "-M", "--cached", "HEAD", "--",
4864                                         oldpath, newpath, NULL
4865                         };
4867                         if (!prepare_update(stage, index_show_argv, opt_cdup, FORMAT_DASH))
4868                                 return REQ_QUIT;
4869                 }
4871                 if (status)
4872                         info = "Staged changes to %s";
4873                 else
4874                         info = "Staged changes";
4875                 break;
4877         case LINE_STAT_UNSTAGED:
4878         {
4879                 const char *files_show_argv[] = {
4880                         "git", "diff-files", "--root", "--patch-with-stat",
4881                                 "-C", "-M", "--", oldpath, newpath, NULL
4882                 };
4884                 if (!prepare_update(stage, files_show_argv, opt_cdup, FORMAT_DASH))
4885                         return REQ_QUIT;
4886                 if (status)
4887                         info = "Unstaged changes to %s";
4888                 else
4889                         info = "Unstaged changes";
4890                 break;
4891         }
4892         case LINE_STAT_UNTRACKED:
4893                 if (!newpath) {
4894                         report("No file to show");
4895                         return REQ_NONE;
4896                 }
4898                 if (!suffixcmp(status->new.name, -1, "/")) {
4899                         report("Cannot display a directory");
4900                         return REQ_NONE;
4901                 }
4903                 if (!prepare_update_file(stage, newpath))
4904                         return REQ_QUIT;
4905                 info = "Untracked file %s";
4906                 break;
4908         case LINE_STAT_HEAD:
4909                 return REQ_NONE;
4911         default:
4912                 die("line type %d not handled in switch", line->type);
4913         }
4915         split = view_is_displayed(view) ? OPEN_SPLIT : 0;
4916         open_view(view, REQ_VIEW_STAGE, OPEN_PREPARED | split);
4917         if (view_is_displayed(VIEW(REQ_VIEW_STAGE))) {
4918                 if (status) {
4919                         stage_status = *status;
4920                 } else {
4921                         memset(&stage_status, 0, sizeof(stage_status));
4922                 }
4924                 stage_line_type = line->type;
4925                 stage_chunks = 0;
4926                 string_format(VIEW(REQ_VIEW_STAGE)->ref, info, stage_status.new.name);
4927         }
4929         return REQ_NONE;
4932 static bool
4933 status_exists(struct status *status, enum line_type type)
4935         struct view *view = VIEW(REQ_VIEW_STATUS);
4936         unsigned long lineno;
4938         for (lineno = 0; lineno < view->lines; lineno++) {
4939                 struct line *line = &view->line[lineno];
4940                 struct status *pos = line->data;
4942                 if (line->type != type)
4943                         continue;
4944                 if (!pos && (!status || !status->status) && line[1].data) {
4945                         select_view_line(view, lineno);
4946                         return TRUE;
4947                 }
4948                 if (pos && !strcmp(status->new.name, pos->new.name)) {
4949                         select_view_line(view, lineno);
4950                         return TRUE;
4951                 }
4952         }
4954         return FALSE;
4958 static bool
4959 status_update_prepare(struct io *io, enum line_type type)
4961         const char *staged_argv[] = {
4962                 "git", "update-index", "-z", "--index-info", NULL
4963         };
4964         const char *others_argv[] = {
4965                 "git", "update-index", "-z", "--add", "--remove", "--stdin", NULL
4966         };
4968         switch (type) {
4969         case LINE_STAT_STAGED:
4970                 return run_io(io, staged_argv, opt_cdup, IO_WR);
4972         case LINE_STAT_UNSTAGED:
4973                 return run_io(io, others_argv, opt_cdup, IO_WR);
4975         case LINE_STAT_UNTRACKED:
4976                 return run_io(io, others_argv, NULL, IO_WR);
4978         default:
4979                 die("line type %d not handled in switch", type);
4980                 return FALSE;
4981         }
4984 static bool
4985 status_update_write(struct io *io, struct status *status, enum line_type type)
4987         char buf[SIZEOF_STR];
4988         size_t bufsize = 0;
4990         switch (type) {
4991         case LINE_STAT_STAGED:
4992                 if (!string_format_from(buf, &bufsize, "%06o %s\t%s%c",
4993                                         status->old.mode,
4994                                         status->old.rev,
4995                                         status->old.name, 0))
4996                         return FALSE;
4997                 break;
4999         case LINE_STAT_UNSTAGED:
5000         case LINE_STAT_UNTRACKED:
5001                 if (!string_format_from(buf, &bufsize, "%s%c", status->new.name, 0))
5002                         return FALSE;
5003                 break;
5005         default:
5006                 die("line type %d not handled in switch", type);
5007         }
5009         return io_write(io, buf, bufsize);
5012 static bool
5013 status_update_file(struct status *status, enum line_type type)
5015         struct io io = {};
5016         bool result;
5018         if (!status_update_prepare(&io, type))
5019                 return FALSE;
5021         result = status_update_write(&io, status, type);
5022         done_io(&io);
5023         return result;
5026 static bool
5027 status_update_files(struct view *view, struct line *line)
5029         struct io io = {};
5030         bool result = TRUE;
5031         struct line *pos = view->line + view->lines;
5032         int files = 0;
5033         int file, done;
5035         if (!status_update_prepare(&io, line->type))
5036                 return FALSE;
5038         for (pos = line; pos < view->line + view->lines && pos->data; pos++)
5039                 files++;
5041         for (file = 0, done = 0; result && file < files; line++, file++) {
5042                 int almost_done = file * 100 / files;
5044                 if (almost_done > done) {
5045                         done = almost_done;
5046                         string_format(view->ref, "updating file %u of %u (%d%% done)",
5047                                       file, files, done);
5048                         update_view_title(view);
5049                 }
5050                 result = status_update_write(&io, line->data, line->type);
5051         }
5053         done_io(&io);
5054         return result;
5057 static bool
5058 status_update(struct view *view)
5060         struct line *line = &view->line[view->lineno];
5062         assert(view->lines);
5064         if (!line->data) {
5065                 /* This should work even for the "On branch" line. */
5066                 if (line < view->line + view->lines && !line[1].data) {
5067                         report("Nothing to update");
5068                         return FALSE;
5069                 }
5071                 if (!status_update_files(view, line + 1)) {
5072                         report("Failed to update file status");
5073                         return FALSE;
5074                 }
5076         } else if (!status_update_file(line->data, line->type)) {
5077                 report("Failed to update file status");
5078                 return FALSE;
5079         }
5081         return TRUE;
5084 static bool
5085 status_revert(struct status *status, enum line_type type, bool has_none)
5087         if (!status || type != LINE_STAT_UNSTAGED) {
5088                 if (type == LINE_STAT_STAGED) {
5089                         report("Cannot revert changes to staged files");
5090                 } else if (type == LINE_STAT_UNTRACKED) {
5091                         report("Cannot revert changes to untracked files");
5092                 } else if (has_none) {
5093                         report("Nothing to revert");
5094                 } else {
5095                         report("Cannot revert changes to multiple files");
5096                 }
5097                 return FALSE;
5099         } else {
5100                 char mode[10] = "100644";
5101                 const char *reset_argv[] = {
5102                         "git", "update-index", "--cacheinfo", mode,
5103                                 status->old.rev, status->old.name, NULL
5104                 };
5105                 const char *checkout_argv[] = {
5106                         "git", "checkout", "--", status->old.name, NULL
5107                 };
5109                 if (!prompt_yesno("Are you sure you want to overwrite any changes?"))
5110                         return FALSE;
5111                 string_format(mode, "%o", status->old.mode);
5112                 return (status->status != 'U' || run_io_fg(reset_argv, opt_cdup)) &&
5113                         run_io_fg(checkout_argv, opt_cdup);
5114         }
5117 static enum request
5118 status_request(struct view *view, enum request request, struct line *line)
5120         struct status *status = line->data;
5122         switch (request) {
5123         case REQ_STATUS_UPDATE:
5124                 if (!status_update(view))
5125                         return REQ_NONE;
5126                 break;
5128         case REQ_STATUS_REVERT:
5129                 if (!status_revert(status, line->type, status_has_none(view, line)))
5130                         return REQ_NONE;
5131                 break;
5133         case REQ_STATUS_MERGE:
5134                 if (!status || status->status != 'U') {
5135                         report("Merging only possible for files with unmerged status ('U').");
5136                         return REQ_NONE;
5137                 }
5138                 open_mergetool(status->new.name);
5139                 break;
5141         case REQ_EDIT:
5142                 if (!status)
5143                         return request;
5144                 if (status->status == 'D') {
5145                         report("File has been deleted.");
5146                         return REQ_NONE;
5147                 }
5149                 open_editor(status->status != '?', status->new.name);
5150                 break;
5152         case REQ_VIEW_BLAME:
5153                 if (status) {
5154                         string_copy(opt_file, status->new.name);
5155                         opt_ref[0] = 0;
5156                 }
5157                 return request;
5159         case REQ_ENTER:
5160                 /* After returning the status view has been split to
5161                  * show the stage view. No further reloading is
5162                  * necessary. */
5163                 status_enter(view, line);
5164                 return REQ_NONE;
5166         case REQ_REFRESH:
5167                 /* Simply reload the view. */
5168                 break;
5170         default:
5171                 return request;
5172         }
5174         open_view(view, REQ_VIEW_STATUS, OPEN_RELOAD);
5176         return REQ_NONE;
5179 static void
5180 status_select(struct view *view, struct line *line)
5182         struct status *status = line->data;
5183         char file[SIZEOF_STR] = "all files";
5184         const char *text;
5185         const char *key;
5187         if (status && !string_format(file, "'%s'", status->new.name))
5188                 return;
5190         if (!status && line[1].type == LINE_STAT_NONE)
5191                 line++;
5193         switch (line->type) {
5194         case LINE_STAT_STAGED:
5195                 text = "Press %s to unstage %s for commit";
5196                 break;
5198         case LINE_STAT_UNSTAGED:
5199                 text = "Press %s to stage %s for commit";
5200                 break;
5202         case LINE_STAT_UNTRACKED:
5203                 text = "Press %s to stage %s for addition";
5204                 break;
5206         case LINE_STAT_HEAD:
5207         case LINE_STAT_NONE:
5208                 text = "Nothing to update";
5209                 break;
5211         default:
5212                 die("line type %d not handled in switch", line->type);
5213         }
5215         if (status && status->status == 'U') {
5216                 text = "Press %s to resolve conflict in %s";
5217                 key = get_key(REQ_STATUS_MERGE);
5219         } else {
5220                 key = get_key(REQ_STATUS_UPDATE);
5221         }
5223         string_format(view->ref, text, key, file);
5226 static bool
5227 status_grep(struct view *view, struct line *line)
5229         struct status *status = line->data;
5230         enum { S_STATUS, S_NAME, S_END } state;
5231         char buf[2] = "?";
5232         regmatch_t pmatch;
5234         if (!status)
5235                 return FALSE;
5237         for (state = S_STATUS; state < S_END; state++) {
5238                 const char *text;
5240                 switch (state) {
5241                 case S_NAME:    text = status->new.name;        break;
5242                 case S_STATUS:
5243                         buf[0] = status->status;
5244                         text = buf;
5245                         break;
5247                 default:
5248                         return FALSE;
5249                 }
5251                 if (regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
5252                         return TRUE;
5253         }
5255         return FALSE;
5258 static struct view_ops status_ops = {
5259         "file",
5260         NULL,
5261         status_open,
5262         NULL,
5263         status_draw,
5264         status_request,
5265         status_grep,
5266         status_select,
5267 };
5270 static bool
5271 stage_diff_write(struct io *io, struct line *line, struct line *end)
5273         while (line < end) {
5274                 if (!io_write(io, line->data, strlen(line->data)) ||
5275                     !io_write(io, "\n", 1))
5276                         return FALSE;
5277                 line++;
5278                 if (line->type == LINE_DIFF_CHUNK ||
5279                     line->type == LINE_DIFF_HEADER)
5280                         break;
5281         }
5283         return TRUE;
5286 static struct line *
5287 stage_diff_find(struct view *view, struct line *line, enum line_type type)
5289         for (; view->line < line; line--)
5290                 if (line->type == type)
5291                         return line;
5293         return NULL;
5296 static bool
5297 stage_apply_chunk(struct view *view, struct line *chunk, bool revert)
5299         const char *apply_argv[SIZEOF_ARG] = {
5300                 "git", "apply", "--whitespace=nowarn", NULL
5301         };
5302         struct line *diff_hdr;
5303         struct io io = {};
5304         int argc = 3;
5306         diff_hdr = stage_diff_find(view, chunk, LINE_DIFF_HEADER);
5307         if (!diff_hdr)
5308                 return FALSE;
5310         if (!revert)
5311                 apply_argv[argc++] = "--cached";
5312         if (revert || stage_line_type == LINE_STAT_STAGED)
5313                 apply_argv[argc++] = "-R";
5314         apply_argv[argc++] = "-";
5315         apply_argv[argc++] = NULL;
5316         if (!run_io(&io, apply_argv, opt_cdup, IO_WR))
5317                 return FALSE;
5319         if (!stage_diff_write(&io, diff_hdr, chunk) ||
5320             !stage_diff_write(&io, chunk, view->line + view->lines))
5321                 chunk = NULL;
5323         done_io(&io);
5324         run_io_bg(update_index_argv);
5326         return chunk ? TRUE : FALSE;
5329 static bool
5330 stage_update(struct view *view, struct line *line)
5332         struct line *chunk = NULL;
5334         if (!is_initial_commit() && stage_line_type != LINE_STAT_UNTRACKED)
5335                 chunk = stage_diff_find(view, line, LINE_DIFF_CHUNK);
5337         if (chunk) {
5338                 if (!stage_apply_chunk(view, chunk, FALSE)) {
5339                         report("Failed to apply chunk");
5340                         return FALSE;
5341                 }
5343         } else if (!stage_status.status) {
5344                 view = VIEW(REQ_VIEW_STATUS);
5346                 for (line = view->line; line < view->line + view->lines; line++)
5347                         if (line->type == stage_line_type)
5348                                 break;
5350                 if (!status_update_files(view, line + 1)) {
5351                         report("Failed to update files");
5352                         return FALSE;
5353                 }
5355         } else if (!status_update_file(&stage_status, stage_line_type)) {
5356                 report("Failed to update file");
5357                 return FALSE;
5358         }
5360         return TRUE;
5363 static bool
5364 stage_revert(struct view *view, struct line *line)
5366         struct line *chunk = NULL;
5368         if (!is_initial_commit() && stage_line_type == LINE_STAT_UNSTAGED)
5369                 chunk = stage_diff_find(view, line, LINE_DIFF_CHUNK);
5371         if (chunk) {
5372                 if (!prompt_yesno("Are you sure you want to revert changes?"))
5373                         return FALSE;
5375                 if (!stage_apply_chunk(view, chunk, TRUE)) {
5376                         report("Failed to revert chunk");
5377                         return FALSE;
5378                 }
5379                 return TRUE;
5381         } else {
5382                 return status_revert(stage_status.status ? &stage_status : NULL,
5383                                      stage_line_type, FALSE);
5384         }
5388 static void
5389 stage_next(struct view *view, struct line *line)
5391         int i;
5393         if (!stage_chunks) {
5394                 static size_t alloc = 0;
5395                 int *tmp;
5397                 for (line = view->line; line < view->line + view->lines; line++) {
5398                         if (line->type != LINE_DIFF_CHUNK)
5399                                 continue;
5401                         tmp = realloc_items(stage_chunk, &alloc,
5402                                             stage_chunks, sizeof(*tmp));
5403                         if (!tmp) {
5404                                 report("Allocation failure");
5405                                 return;
5406                         }
5408                         stage_chunk = tmp;
5409                         stage_chunk[stage_chunks++] = line - view->line;
5410                 }
5411         }
5413         for (i = 0; i < stage_chunks; i++) {
5414                 if (stage_chunk[i] > view->lineno) {
5415                         do_scroll_view(view, stage_chunk[i] - view->lineno);
5416                         report("Chunk %d of %d", i + 1, stage_chunks);
5417                         return;
5418                 }
5419         }
5421         report("No next chunk found");
5424 static enum request
5425 stage_request(struct view *view, enum request request, struct line *line)
5427         switch (request) {
5428         case REQ_STATUS_UPDATE:
5429                 if (!stage_update(view, line))
5430                         return REQ_NONE;
5431                 break;
5433         case REQ_STATUS_REVERT:
5434                 if (!stage_revert(view, line))
5435                         return REQ_NONE;
5436                 break;
5438         case REQ_STAGE_NEXT:
5439                 if (stage_line_type == LINE_STAT_UNTRACKED) {
5440                         report("File is untracked; press %s to add",
5441                                get_key(REQ_STATUS_UPDATE));
5442                         return REQ_NONE;
5443                 }
5444                 stage_next(view, line);
5445                 return REQ_NONE;
5447         case REQ_EDIT:
5448                 if (!stage_status.new.name[0])
5449                         return request;
5450                 if (stage_status.status == 'D') {
5451                         report("File has been deleted.");
5452                         return REQ_NONE;
5453                 }
5455                 open_editor(stage_status.status != '?', stage_status.new.name);
5456                 break;
5458         case REQ_REFRESH:
5459                 /* Reload everything ... */
5460                 break;
5462         case REQ_VIEW_BLAME:
5463                 if (stage_status.new.name[0]) {
5464                         string_copy(opt_file, stage_status.new.name);
5465                         opt_ref[0] = 0;
5466                 }
5467                 return request;
5469         case REQ_ENTER:
5470                 return pager_request(view, request, line);
5472         default:
5473                 return request;
5474         }
5476         VIEW(REQ_VIEW_STATUS)->p_restore = TRUE;
5477         open_view(view, REQ_VIEW_STATUS, OPEN_RELOAD | OPEN_NOMAXIMIZE);
5479         /* Check whether the staged entry still exists, and close the
5480          * stage view if it doesn't. */
5481         if (!status_exists(&stage_status, stage_line_type)) {
5482                 status_restore(VIEW(REQ_VIEW_STATUS));
5483                 return REQ_VIEW_CLOSE;
5484         }
5486         if (stage_line_type == LINE_STAT_UNTRACKED) {
5487                 if (!suffixcmp(stage_status.new.name, -1, "/")) {
5488                         report("Cannot display a directory");
5489                         return REQ_NONE;
5490                 }
5492                 if (!prepare_update_file(view, stage_status.new.name)) {
5493                         report("Failed to open file: %s", strerror(errno));
5494                         return REQ_NONE;
5495                 }
5496         }
5497         open_view(view, REQ_VIEW_STAGE, OPEN_REFRESH);
5499         return REQ_NONE;
5502 static struct view_ops stage_ops = {
5503         "line",
5504         NULL,
5505         NULL,
5506         pager_read,
5507         pager_draw,
5508         stage_request,
5509         pager_grep,
5510         pager_select,
5511 };
5514 /*
5515  * Revision graph
5516  */
5518 struct commit {
5519         char id[SIZEOF_REV];            /* SHA1 ID. */
5520         char title[128];                /* First line of the commit message. */
5521         char author[75];                /* Author of the commit. */
5522         struct tm time;                 /* Date from the author ident. */
5523         struct ref **refs;              /* Repository references. */
5524         chtype graph[SIZEOF_REVGRAPH];  /* Ancestry chain graphics. */
5525         size_t graph_size;              /* The width of the graph array. */
5526         bool has_parents;               /* Rewritten --parents seen. */
5527 };
5529 /* Size of rev graph with no  "padding" columns */
5530 #define SIZEOF_REVITEMS (SIZEOF_REVGRAPH - (SIZEOF_REVGRAPH / 2))
5532 struct rev_graph {
5533         struct rev_graph *prev, *next, *parents;
5534         char rev[SIZEOF_REVITEMS][SIZEOF_REV];
5535         size_t size;
5536         struct commit *commit;
5537         size_t pos;
5538         unsigned int boundary:1;
5539 };
5541 /* Parents of the commit being visualized. */
5542 static struct rev_graph graph_parents[4];
5544 /* The current stack of revisions on the graph. */
5545 static struct rev_graph graph_stacks[4] = {
5546         { &graph_stacks[3], &graph_stacks[1], &graph_parents[0] },
5547         { &graph_stacks[0], &graph_stacks[2], &graph_parents[1] },
5548         { &graph_stacks[1], &graph_stacks[3], &graph_parents[2] },
5549         { &graph_stacks[2], &graph_stacks[0], &graph_parents[3] },
5550 };
5552 static inline bool
5553 graph_parent_is_merge(struct rev_graph *graph)
5555         return graph->parents->size > 1;
5558 static inline void
5559 append_to_rev_graph(struct rev_graph *graph, chtype symbol)
5561         struct commit *commit = graph->commit;
5563         if (commit->graph_size < ARRAY_SIZE(commit->graph) - 1)
5564                 commit->graph[commit->graph_size++] = symbol;
5567 static void
5568 clear_rev_graph(struct rev_graph *graph)
5570         graph->boundary = 0;
5571         graph->size = graph->pos = 0;
5572         graph->commit = NULL;
5573         memset(graph->parents, 0, sizeof(*graph->parents));
5576 static void
5577 done_rev_graph(struct rev_graph *graph)
5579         if (graph_parent_is_merge(graph) &&
5580             graph->pos < graph->size - 1 &&
5581             graph->next->size == graph->size + graph->parents->size - 1) {
5582                 size_t i = graph->pos + graph->parents->size - 1;
5584                 graph->commit->graph_size = i * 2;
5585                 while (i < graph->next->size - 1) {
5586                         append_to_rev_graph(graph, ' ');
5587                         append_to_rev_graph(graph, '\\');
5588                         i++;
5589                 }
5590         }
5592         clear_rev_graph(graph);
5595 static void
5596 push_rev_graph(struct rev_graph *graph, const char *parent)
5598         int i;
5600         /* "Collapse" duplicate parents lines.
5601          *
5602          * FIXME: This needs to also update update the drawn graph but
5603          * for now it just serves as a method for pruning graph lines. */
5604         for (i = 0; i < graph->size; i++)
5605                 if (!strncmp(graph->rev[i], parent, SIZEOF_REV))
5606                         return;
5608         if (graph->size < SIZEOF_REVITEMS) {
5609                 string_copy_rev(graph->rev[graph->size++], parent);
5610         }
5613 static chtype
5614 get_rev_graph_symbol(struct rev_graph *graph)
5616         chtype symbol;
5618         if (graph->boundary)
5619                 symbol = REVGRAPH_BOUND;
5620         else if (graph->parents->size == 0)
5621                 symbol = REVGRAPH_INIT;
5622         else if (graph_parent_is_merge(graph))
5623                 symbol = REVGRAPH_MERGE;
5624         else if (graph->pos >= graph->size)
5625                 symbol = REVGRAPH_BRANCH;
5626         else
5627                 symbol = REVGRAPH_COMMIT;
5629         return symbol;
5632 static void
5633 draw_rev_graph(struct rev_graph *graph)
5635         struct rev_filler {
5636                 chtype separator, line;
5637         };
5638         enum { DEFAULT, RSHARP, RDIAG, LDIAG };
5639         static struct rev_filler fillers[] = {
5640                 { ' ',  '|' },
5641                 { '`',  '.' },
5642                 { '\'', ' ' },
5643                 { '/',  ' ' },
5644         };
5645         chtype symbol = get_rev_graph_symbol(graph);
5646         struct rev_filler *filler;
5647         size_t i;
5649         if (opt_line_graphics)
5650                 fillers[DEFAULT].line = line_graphics[LINE_GRAPHIC_VLINE];
5652         filler = &fillers[DEFAULT];
5654         for (i = 0; i < graph->pos; i++) {
5655                 append_to_rev_graph(graph, filler->line);
5656                 if (graph_parent_is_merge(graph->prev) &&
5657                     graph->prev->pos == i)
5658                         filler = &fillers[RSHARP];
5660                 append_to_rev_graph(graph, filler->separator);
5661         }
5663         /* Place the symbol for this revision. */
5664         append_to_rev_graph(graph, symbol);
5666         if (graph->prev->size > graph->size)
5667                 filler = &fillers[RDIAG];
5668         else
5669                 filler = &fillers[DEFAULT];
5671         i++;
5673         for (; i < graph->size; i++) {
5674                 append_to_rev_graph(graph, filler->separator);
5675                 append_to_rev_graph(graph, filler->line);
5676                 if (graph_parent_is_merge(graph->prev) &&
5677                     i < graph->prev->pos + graph->parents->size)
5678                         filler = &fillers[RSHARP];
5679                 if (graph->prev->size > graph->size)
5680                         filler = &fillers[LDIAG];
5681         }
5683         if (graph->prev->size > graph->size) {
5684                 append_to_rev_graph(graph, filler->separator);
5685                 if (filler->line != ' ')
5686                         append_to_rev_graph(graph, filler->line);
5687         }
5690 /* Prepare the next rev graph */
5691 static void
5692 prepare_rev_graph(struct rev_graph *graph)
5694         size_t i;
5696         /* First, traverse all lines of revisions up to the active one. */
5697         for (graph->pos = 0; graph->pos < graph->size; graph->pos++) {
5698                 if (!strcmp(graph->rev[graph->pos], graph->commit->id))
5699                         break;
5701                 push_rev_graph(graph->next, graph->rev[graph->pos]);
5702         }
5704         /* Interleave the new revision parent(s). */
5705         for (i = 0; !graph->boundary && i < graph->parents->size; i++)
5706                 push_rev_graph(graph->next, graph->parents->rev[i]);
5708         /* Lastly, put any remaining revisions. */
5709         for (i = graph->pos + 1; i < graph->size; i++)
5710                 push_rev_graph(graph->next, graph->rev[i]);
5713 static void
5714 update_rev_graph(struct view *view, struct rev_graph *graph)
5716         /* If this is the finalizing update ... */
5717         if (graph->commit)
5718                 prepare_rev_graph(graph);
5720         /* Graph visualization needs a one rev look-ahead,
5721          * so the first update doesn't visualize anything. */
5722         if (!graph->prev->commit)
5723                 return;
5725         if (view->lines > 2)
5726                 view->line[view->lines - 3].dirty = 1;
5727         if (view->lines > 1)
5728                 view->line[view->lines - 2].dirty = 1;
5729         draw_rev_graph(graph->prev);
5730         done_rev_graph(graph->prev->prev);
5734 /*
5735  * Main view backend
5736  */
5738 static const char *main_argv[SIZEOF_ARG] = {
5739         "git", "log", "--no-color", "--pretty=raw", "--parents",
5740                       "--topo-order", "%(head)", NULL
5741 };
5743 static bool
5744 main_draw(struct view *view, struct line *line, unsigned int lineno)
5746         struct commit *commit = line->data;
5748         if (!*commit->author)
5749                 return FALSE;
5751         if (opt_date && draw_date(view, &commit->time))
5752                 return TRUE;
5754         if (opt_author && draw_author(view, commit->author))
5755                 return TRUE;
5757         if (opt_rev_graph && commit->graph_size &&
5758             draw_graphic(view, LINE_MAIN_REVGRAPH, commit->graph, commit->graph_size))
5759                 return TRUE;
5761         if (opt_show_refs && commit->refs) {
5762                 size_t i = 0;
5764                 do {
5765                         enum line_type type;
5767                         if (commit->refs[i]->head)
5768                                 type = LINE_MAIN_HEAD;
5769                         else if (commit->refs[i]->ltag)
5770                                 type = LINE_MAIN_LOCAL_TAG;
5771                         else if (commit->refs[i]->tag)
5772                                 type = LINE_MAIN_TAG;
5773                         else if (commit->refs[i]->tracked)
5774                                 type = LINE_MAIN_TRACKED;
5775                         else if (commit->refs[i]->remote)
5776                                 type = LINE_MAIN_REMOTE;
5777                         else
5778                                 type = LINE_MAIN_REF;
5780                         if (draw_text(view, type, "[", TRUE) ||
5781                             draw_text(view, type, commit->refs[i]->name, TRUE) ||
5782                             draw_text(view, type, "]", TRUE))
5783                                 return TRUE;
5785                         if (draw_text(view, LINE_DEFAULT, " ", TRUE))
5786                                 return TRUE;
5787                 } while (commit->refs[i++]->next);
5788         }
5790         draw_text(view, LINE_DEFAULT, commit->title, TRUE);
5791         return TRUE;
5794 /* Reads git log --pretty=raw output and parses it into the commit struct. */
5795 static bool
5796 main_read(struct view *view, char *line)
5798         static struct rev_graph *graph = graph_stacks;
5799         enum line_type type;
5800         struct commit *commit;
5802         if (!line) {
5803                 int i;
5805                 if (!view->lines && !view->parent)
5806                         die("No revisions match the given arguments.");
5807                 if (view->lines > 0) {
5808                         commit = view->line[view->lines - 1].data;
5809                         view->line[view->lines - 1].dirty = 1;
5810                         if (!*commit->author) {
5811                                 view->lines--;
5812                                 free(commit);
5813                                 graph->commit = NULL;
5814                         }
5815                 }
5816                 update_rev_graph(view, graph);
5818                 for (i = 0; i < ARRAY_SIZE(graph_stacks); i++)
5819                         clear_rev_graph(&graph_stacks[i]);
5820                 return TRUE;
5821         }
5823         type = get_line_type(line);
5824         if (type == LINE_COMMIT) {
5825                 commit = calloc(1, sizeof(struct commit));
5826                 if (!commit)
5827                         return FALSE;
5829                 line += STRING_SIZE("commit ");
5830                 if (*line == '-') {
5831                         graph->boundary = 1;
5832                         line++;
5833                 }
5835                 string_copy_rev(commit->id, line);
5836                 commit->refs = get_refs(commit->id);
5837                 graph->commit = commit;
5838                 add_line_data(view, commit, LINE_MAIN_COMMIT);
5840                 while ((line = strchr(line, ' '))) {
5841                         line++;
5842                         push_rev_graph(graph->parents, line);
5843                         commit->has_parents = TRUE;
5844                 }
5845                 return TRUE;
5846         }
5848         if (!view->lines)
5849                 return TRUE;
5850         commit = view->line[view->lines - 1].data;
5852         switch (type) {
5853         case LINE_PARENT:
5854                 if (commit->has_parents)
5855                         break;
5856                 push_rev_graph(graph->parents, line + STRING_SIZE("parent "));
5857                 break;
5859         case LINE_AUTHOR:
5860                 parse_author_line(line + STRING_SIZE("author "),
5861                                   commit->author, sizeof(commit->author),
5862                                   &commit->time);
5863                 update_rev_graph(view, graph);
5864                 graph = graph->next;
5865                 break;
5867         default:
5868                 /* Fill in the commit title if it has not already been set. */
5869                 if (commit->title[0])
5870                         break;
5872                 /* Require titles to start with a non-space character at the
5873                  * offset used by git log. */
5874                 if (strncmp(line, "    ", 4))
5875                         break;
5876                 line += 4;
5877                 /* Well, if the title starts with a whitespace character,
5878                  * try to be forgiving.  Otherwise we end up with no title. */
5879                 while (isspace(*line))
5880                         line++;
5881                 if (*line == '\0')
5882                         break;
5883                 /* FIXME: More graceful handling of titles; append "..." to
5884                  * shortened titles, etc. */
5886                 string_expand(commit->title, sizeof(commit->title), line, 1);
5887                 view->line[view->lines - 1].dirty = 1;
5888         }
5890         return TRUE;
5893 static enum request
5894 main_request(struct view *view, enum request request, struct line *line)
5896         enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
5898         switch (request) {
5899         case REQ_ENTER:
5900                 open_view(view, REQ_VIEW_DIFF, flags);
5901                 break;
5902         case REQ_REFRESH:
5903                 load_refs();
5904                 open_view(view, REQ_VIEW_MAIN, OPEN_REFRESH);
5905                 break;
5906         default:
5907                 return request;
5908         }
5910         return REQ_NONE;
5913 static bool
5914 grep_refs(struct ref **refs, regex_t *regex)
5916         regmatch_t pmatch;
5917         size_t i = 0;
5919         if (!refs)
5920                 return FALSE;
5921         do {
5922                 if (regexec(regex, refs[i]->name, 1, &pmatch, 0) != REG_NOMATCH)
5923                         return TRUE;
5924         } while (refs[i++]->next);
5926         return FALSE;
5929 static bool
5930 main_grep(struct view *view, struct line *line)
5932         struct commit *commit = line->data;
5933         enum { S_TITLE, S_AUTHOR, S_DATE, S_REFS, S_END } state;
5934         char buf[DATE_COLS + 1];
5935         regmatch_t pmatch;
5937         for (state = S_TITLE; state < S_END; state++) {
5938                 char *text;
5940                 switch (state) {
5941                 case S_TITLE:   text = commit->title;   break;
5942                 case S_AUTHOR:
5943                         if (!opt_author)
5944                                 continue;
5945                         text = commit->author;
5946                         break;
5947                 case S_DATE:
5948                         if (!opt_date)
5949                                 continue;
5950                         if (!strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time))
5951                                 continue;
5952                         text = buf;
5953                         break;
5954                 case S_REFS:
5955                         if (!opt_show_refs)
5956                                 continue;
5957                         if (grep_refs(commit->refs, view->regex) == TRUE)
5958                                 return TRUE;
5959                         continue;
5960                 default:
5961                         return FALSE;
5962                 }
5964                 if (regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
5965                         return TRUE;
5966         }
5968         return FALSE;
5971 static void
5972 main_select(struct view *view, struct line *line)
5974         struct commit *commit = line->data;
5976         string_copy_rev(view->ref, commit->id);
5977         string_copy_rev(ref_commit, view->ref);
5980 static struct view_ops main_ops = {
5981         "commit",
5982         main_argv,
5983         NULL,
5984         main_read,
5985         main_draw,
5986         main_request,
5987         main_grep,
5988         main_select,
5989 };
5992 /*
5993  * Unicode / UTF-8 handling
5994  *
5995  * NOTE: Much of the following code for dealing with unicode is derived from
5996  * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
5997  * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
5998  */
6000 /* I've (over)annotated a lot of code snippets because I am not entirely
6001  * confident that the approach taken by this small UTF-8 interface is correct.
6002  * --jonas */
6004 static inline int
6005 unicode_width(unsigned long c)
6007         if (c >= 0x1100 &&
6008            (c <= 0x115f                         /* Hangul Jamo */
6009             || c == 0x2329
6010             || c == 0x232a
6011             || (c >= 0x2e80  && c <= 0xa4cf && c != 0x303f)
6012                                                 /* CJK ... Yi */
6013             || (c >= 0xac00  && c <= 0xd7a3)    /* Hangul Syllables */
6014             || (c >= 0xf900  && c <= 0xfaff)    /* CJK Compatibility Ideographs */
6015             || (c >= 0xfe30  && c <= 0xfe6f)    /* CJK Compatibility Forms */
6016             || (c >= 0xff00  && c <= 0xff60)    /* Fullwidth Forms */
6017             || (c >= 0xffe0  && c <= 0xffe6)
6018             || (c >= 0x20000 && c <= 0x2fffd)
6019             || (c >= 0x30000 && c <= 0x3fffd)))
6020                 return 2;
6022         if (c == '\t')
6023                 return opt_tab_size;
6025         return 1;
6028 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
6029  * Illegal bytes are set one. */
6030 static const unsigned char utf8_bytes[256] = {
6031         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,
6032         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,
6033         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,
6034         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,
6035         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,
6036         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,
6037         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,
6038         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,
6039 };
6041 /* Decode UTF-8 multi-byte representation into a unicode character. */
6042 static inline unsigned long
6043 utf8_to_unicode(const char *string, size_t length)
6045         unsigned long unicode;
6047         switch (length) {
6048         case 1:
6049                 unicode  =   string[0];
6050                 break;
6051         case 2:
6052                 unicode  =  (string[0] & 0x1f) << 6;
6053                 unicode +=  (string[1] & 0x3f);
6054                 break;
6055         case 3:
6056                 unicode  =  (string[0] & 0x0f) << 12;
6057                 unicode += ((string[1] & 0x3f) << 6);
6058                 unicode +=  (string[2] & 0x3f);
6059                 break;
6060         case 4:
6061                 unicode  =  (string[0] & 0x0f) << 18;
6062                 unicode += ((string[1] & 0x3f) << 12);
6063                 unicode += ((string[2] & 0x3f) << 6);
6064                 unicode +=  (string[3] & 0x3f);
6065                 break;
6066         case 5:
6067                 unicode  =  (string[0] & 0x0f) << 24;
6068                 unicode += ((string[1] & 0x3f) << 18);
6069                 unicode += ((string[2] & 0x3f) << 12);
6070                 unicode += ((string[3] & 0x3f) << 6);
6071                 unicode +=  (string[4] & 0x3f);
6072                 break;
6073         case 6:
6074                 unicode  =  (string[0] & 0x01) << 30;
6075                 unicode += ((string[1] & 0x3f) << 24);
6076                 unicode += ((string[2] & 0x3f) << 18);
6077                 unicode += ((string[3] & 0x3f) << 12);
6078                 unicode += ((string[4] & 0x3f) << 6);
6079                 unicode +=  (string[5] & 0x3f);
6080                 break;
6081         default:
6082                 die("Invalid unicode length");
6083         }
6085         /* Invalid characters could return the special 0xfffd value but NUL
6086          * should be just as good. */
6087         return unicode > 0xffff ? 0 : unicode;
6090 /* Calculates how much of string can be shown within the given maximum width
6091  * and sets trimmed parameter to non-zero value if all of string could not be
6092  * shown. If the reserve flag is TRUE, it will reserve at least one
6093  * trailing character, which can be useful when drawing a delimiter.
6094  *
6095  * Returns the number of bytes to output from string to satisfy max_width. */
6096 static size_t
6097 utf8_length(const char **start, size_t skip, int *width, size_t max_width, int *trimmed, bool reserve)
6099         const char *string = *start;
6100         const char *end = strchr(string, '\0');
6101         unsigned char last_bytes = 0;
6102         size_t last_ucwidth = 0;
6104         *width = 0;
6105         *trimmed = 0;
6107         while (string < end) {
6108                 int c = *(unsigned char *) string;
6109                 unsigned char bytes = utf8_bytes[c];
6110                 size_t ucwidth;
6111                 unsigned long unicode;
6113                 if (string + bytes > end)
6114                         break;
6116                 /* Change representation to figure out whether
6117                  * it is a single- or double-width character. */
6119                 unicode = utf8_to_unicode(string, bytes);
6120                 /* FIXME: Graceful handling of invalid unicode character. */
6121                 if (!unicode)
6122                         break;
6124                 ucwidth = unicode_width(unicode);
6125                 if (skip > 0) {
6126                         skip -= ucwidth <= skip ? ucwidth : skip;
6127                         *start += bytes;
6128                 }
6129                 *width  += ucwidth;
6130                 if (*width > max_width) {
6131                         *trimmed = 1;
6132                         *width -= ucwidth;
6133                         if (reserve && *width == max_width) {
6134                                 string -= last_bytes;
6135                                 *width -= last_ucwidth;
6136                         }
6137                         break;
6138                 }
6140                 string  += bytes;
6141                 last_bytes = ucwidth ? bytes : 0;
6142                 last_ucwidth = ucwidth;
6143         }
6145         return string - *start;
6149 /*
6150  * Status management
6151  */
6153 /* Whether or not the curses interface has been initialized. */
6154 static bool cursed = FALSE;
6156 /* Terminal hacks and workarounds. */
6157 static bool use_scroll_redrawwin;
6158 static bool use_scroll_status_wclear;
6160 /* The status window is used for polling keystrokes. */
6161 static WINDOW *status_win;
6163 /* Reading from the prompt? */
6164 static bool input_mode = FALSE;
6166 static bool status_empty = FALSE;
6168 /* Update status and title window. */
6169 static void
6170 report(const char *msg, ...)
6172         struct view *view = display[current_view];
6174         if (input_mode)
6175                 return;
6177         if (!view) {
6178                 char buf[SIZEOF_STR];
6179                 va_list args;
6181                 va_start(args, msg);
6182                 if (vsnprintf(buf, sizeof(buf), msg, args) >= sizeof(buf)) {
6183                         buf[sizeof(buf) - 1] = 0;
6184                         buf[sizeof(buf) - 2] = '.';
6185                         buf[sizeof(buf) - 3] = '.';
6186                         buf[sizeof(buf) - 4] = '.';
6187                 }
6188                 va_end(args);
6189                 die("%s", buf);
6190         }
6192         if (!status_empty || *msg) {
6193                 va_list args;
6195                 va_start(args, msg);
6197                 wmove(status_win, 0, 0);
6198                 if (view->has_scrolled && use_scroll_status_wclear)
6199                         wclear(status_win);
6200                 if (*msg) {
6201                         vwprintw(status_win, msg, args);
6202                         status_empty = FALSE;
6203                 } else {
6204                         status_empty = TRUE;
6205                 }
6206                 wclrtoeol(status_win);
6207                 wnoutrefresh(status_win);
6209                 va_end(args);
6210         }
6212         update_view_title(view);
6215 /* Controls when nodelay should be in effect when polling user input. */
6216 static void
6217 set_nonblocking_input(bool loading)
6219         static unsigned int loading_views;
6221         if ((loading == FALSE && loading_views-- == 1) ||
6222             (loading == TRUE  && loading_views++ == 0))
6223                 nodelay(status_win, loading);
6226 static void
6227 init_display(void)
6229         const char *term;
6230         int x, y;
6232         /* Initialize the curses library */
6233         if (isatty(STDIN_FILENO)) {
6234                 cursed = !!initscr();
6235                 opt_tty = stdin;
6236         } else {
6237                 /* Leave stdin and stdout alone when acting as a pager. */
6238                 opt_tty = fopen("/dev/tty", "r+");
6239                 if (!opt_tty)
6240                         die("Failed to open /dev/tty");
6241                 cursed = !!newterm(NULL, opt_tty, opt_tty);
6242         }
6244         if (!cursed)
6245                 die("Failed to initialize curses");
6247         nonl();         /* Tell curses not to do NL->CR/NL on output */
6248         cbreak();       /* Take input chars one at a time, no wait for \n */
6249         noecho();       /* Don't echo input */
6250         leaveok(stdscr, FALSE);
6252         if (has_colors())
6253                 init_colors();
6255         getmaxyx(stdscr, y, x);
6256         status_win = newwin(1, 0, y - 1, 0);
6257         if (!status_win)
6258                 die("Failed to create status window");
6260         /* Enable keyboard mapping */
6261         keypad(status_win, TRUE);
6262         wbkgdset(status_win, get_line_attr(LINE_STATUS));
6264         TABSIZE = opt_tab_size;
6265         if (opt_line_graphics) {
6266                 line_graphics[LINE_GRAPHIC_VLINE] = ACS_VLINE;
6267         }
6269         term = getenv("XTERM_VERSION") ? NULL : getenv("COLORTERM");
6270         if (term && !strcmp(term, "gnome-terminal")) {
6271                 /* In the gnome-terminal-emulator, the message from
6272                  * scrolling up one line when impossible followed by
6273                  * scrolling down one line causes corruption of the
6274                  * status line. This is fixed by calling wclear. */
6275                 use_scroll_status_wclear = TRUE;
6276                 use_scroll_redrawwin = FALSE;
6278         } else if (term && !strcmp(term, "xrvt-xpm")) {
6279                 /* No problems with full optimizations in xrvt-(unicode)
6280                  * and aterm. */
6281                 use_scroll_status_wclear = use_scroll_redrawwin = FALSE;
6283         } else {
6284                 /* When scrolling in (u)xterm the last line in the
6285                  * scrolling direction will update slowly. */
6286                 use_scroll_redrawwin = TRUE;
6287                 use_scroll_status_wclear = FALSE;
6288         }
6291 static int
6292 get_input(int prompt_position)
6294         struct view *view;
6295         int i, key, cursor_y, cursor_x;
6297         if (prompt_position)
6298                 input_mode = TRUE;
6300         while (TRUE) {
6301                 foreach_view (view, i) {
6302                         update_view(view);
6303                         if (view_is_displayed(view) && view->has_scrolled &&
6304                             use_scroll_redrawwin)
6305                                 redrawwin(view->win);
6306                         view->has_scrolled = FALSE;
6307                 }
6309                 /* Update the cursor position. */
6310                 if (prompt_position) {
6311                         getbegyx(status_win, cursor_y, cursor_x);
6312                         cursor_x = prompt_position;
6313                 } else {
6314                         view = display[current_view];
6315                         getbegyx(view->win, cursor_y, cursor_x);
6316                         cursor_x = view->width - 1;
6317                         cursor_y += view->lineno - view->offset;
6318                 }
6319                 setsyx(cursor_y, cursor_x);
6321                 /* Refresh, accept single keystroke of input */
6322                 doupdate();
6323                 key = wgetch(status_win);
6325                 /* wgetch() with nodelay() enabled returns ERR when
6326                  * there's no input. */
6327                 if (key == ERR) {
6329                 } else if (key == KEY_RESIZE) {
6330                         int height, width;
6332                         getmaxyx(stdscr, height, width);
6334                         wresize(status_win, 1, width);
6335                         mvwin(status_win, height - 1, 0);
6336                         wnoutrefresh(status_win);
6337                         resize_display();
6338                         redraw_display(TRUE);
6340                 } else {
6341                         input_mode = FALSE;
6342                         return key;
6343                 }
6344         }
6347 static char *
6348 prompt_input(const char *prompt, input_handler handler, void *data)
6350         enum input_status status = INPUT_OK;
6351         static char buf[SIZEOF_STR];
6352         size_t pos = 0;
6354         buf[pos] = 0;
6356         while (status == INPUT_OK || status == INPUT_SKIP) {
6357                 int key;
6359                 mvwprintw(status_win, 0, 0, "%s%.*s", prompt, pos, buf);
6360                 wclrtoeol(status_win);
6362                 key = get_input(pos + 1);
6363                 switch (key) {
6364                 case KEY_RETURN:
6365                 case KEY_ENTER:
6366                 case '\n':
6367                         status = pos ? INPUT_STOP : INPUT_CANCEL;
6368                         break;
6370                 case KEY_BACKSPACE:
6371                         if (pos > 0)
6372                                 buf[--pos] = 0;
6373                         else
6374                                 status = INPUT_CANCEL;
6375                         break;
6377                 case KEY_ESC:
6378                         status = INPUT_CANCEL;
6379                         break;
6381                 default:
6382                         if (pos >= sizeof(buf)) {
6383                                 report("Input string too long");
6384                                 return NULL;
6385                         }
6387                         status = handler(data, buf, key);
6388                         if (status == INPUT_OK)
6389                                 buf[pos++] = (char) key;
6390                 }
6391         }
6393         /* Clear the status window */
6394         status_empty = FALSE;
6395         report("");
6397         if (status == INPUT_CANCEL)
6398                 return NULL;
6400         buf[pos++] = 0;
6402         return buf;
6405 static enum input_status
6406 prompt_yesno_handler(void *data, char *buf, int c)
6408         if (c == 'y' || c == 'Y')
6409                 return INPUT_STOP;
6410         if (c == 'n' || c == 'N')
6411                 return INPUT_CANCEL;
6412         return INPUT_SKIP;
6415 static bool
6416 prompt_yesno(const char *prompt)
6418         char prompt2[SIZEOF_STR];
6420         if (!string_format(prompt2, "%s [Yy/Nn]", prompt))
6421                 return FALSE;
6423         return !!prompt_input(prompt2, prompt_yesno_handler, NULL);
6426 static enum input_status
6427 read_prompt_handler(void *data, char *buf, int c)
6429         return isprint(c) ? INPUT_OK : INPUT_SKIP;
6432 static char *
6433 read_prompt(const char *prompt)
6435         return prompt_input(prompt, read_prompt_handler, NULL);
6438 /*
6439  * Repository properties
6440  */
6442 static struct ref *refs = NULL;
6443 static size_t refs_alloc = 0;
6444 static size_t refs_size = 0;
6446 /* Id <-> ref store */
6447 static struct ref ***id_refs = NULL;
6448 static size_t id_refs_alloc = 0;
6449 static size_t id_refs_size = 0;
6451 static int
6452 compare_refs(const void *ref1_, const void *ref2_)
6454         const struct ref *ref1 = *(const struct ref **)ref1_;
6455         const struct ref *ref2 = *(const struct ref **)ref2_;
6457         if (ref1->tag != ref2->tag)
6458                 return ref2->tag - ref1->tag;
6459         if (ref1->ltag != ref2->ltag)
6460                 return ref2->ltag - ref2->ltag;
6461         if (ref1->head != ref2->head)
6462                 return ref2->head - ref1->head;
6463         if (ref1->tracked != ref2->tracked)
6464                 return ref2->tracked - ref1->tracked;
6465         if (ref1->remote != ref2->remote)
6466                 return ref2->remote - ref1->remote;
6467         return strcmp(ref1->name, ref2->name);
6470 static struct ref **
6471 get_refs(const char *id)
6473         struct ref ***tmp_id_refs;
6474         struct ref **ref_list = NULL;
6475         size_t ref_list_alloc = 0;
6476         size_t ref_list_size = 0;
6477         size_t i;
6479         for (i = 0; i < id_refs_size; i++)
6480                 if (!strcmp(id, id_refs[i][0]->id))
6481                         return id_refs[i];
6483         tmp_id_refs = realloc_items(id_refs, &id_refs_alloc, id_refs_size + 1,
6484                                     sizeof(*id_refs));
6485         if (!tmp_id_refs)
6486                 return NULL;
6488         id_refs = tmp_id_refs;
6490         for (i = 0; i < refs_size; i++) {
6491                 struct ref **tmp;
6493                 if (strcmp(id, refs[i].id))
6494                         continue;
6496                 tmp = realloc_items(ref_list, &ref_list_alloc,
6497                                     ref_list_size + 1, sizeof(*ref_list));
6498                 if (!tmp) {
6499                         if (ref_list)
6500                                 free(ref_list);
6501                         return NULL;
6502                 }
6504                 ref_list = tmp;
6505                 ref_list[ref_list_size] = &refs[i];
6506                 /* XXX: The properties of the commit chains ensures that we can
6507                  * safely modify the shared ref. The repo references will
6508                  * always be similar for the same id. */
6509                 ref_list[ref_list_size]->next = 1;
6511                 ref_list_size++;
6512         }
6514         if (ref_list) {
6515                 qsort(ref_list, ref_list_size, sizeof(*ref_list), compare_refs);
6516                 ref_list[ref_list_size - 1]->next = 0;
6517                 id_refs[id_refs_size++] = ref_list;
6518         }
6520         return ref_list;
6523 static int
6524 read_ref(char *id, size_t idlen, char *name, size_t namelen)
6526         struct ref *ref;
6527         bool tag = FALSE;
6528         bool ltag = FALSE;
6529         bool remote = FALSE;
6530         bool tracked = FALSE;
6531         bool check_replace = FALSE;
6532         bool head = FALSE;
6534         if (!prefixcmp(name, "refs/tags/")) {
6535                 if (!suffixcmp(name, namelen, "^{}")) {
6536                         namelen -= 3;
6537                         name[namelen] = 0;
6538                         if (refs_size > 0 && refs[refs_size - 1].ltag == TRUE)
6539                                 check_replace = TRUE;
6540                 } else {
6541                         ltag = TRUE;
6542                 }
6544                 tag = TRUE;
6545                 namelen -= STRING_SIZE("refs/tags/");
6546                 name    += STRING_SIZE("refs/tags/");
6548         } else if (!prefixcmp(name, "refs/remotes/")) {
6549                 remote = TRUE;
6550                 namelen -= STRING_SIZE("refs/remotes/");
6551                 name    += STRING_SIZE("refs/remotes/");
6552                 tracked  = !strcmp(opt_remote, name);
6554         } else if (!prefixcmp(name, "refs/heads/")) {
6555                 namelen -= STRING_SIZE("refs/heads/");
6556                 name    += STRING_SIZE("refs/heads/");
6557                 head     = !strncmp(opt_head, name, namelen);
6559         } else if (!strcmp(name, "HEAD")) {
6560                 string_ncopy(opt_head_rev, id, idlen);
6561                 return OK;
6562         }
6564         if (check_replace && !strcmp(name, refs[refs_size - 1].name)) {
6565                 /* it's an annotated tag, replace the previous sha1 with the
6566                  * resolved commit id; relies on the fact git-ls-remote lists
6567                  * the commit id of an annotated tag right before the commit id
6568                  * it points to. */
6569                 refs[refs_size - 1].ltag = ltag;
6570                 string_copy_rev(refs[refs_size - 1].id, id);
6572                 return OK;
6573         }
6574         refs = realloc_items(refs, &refs_alloc, refs_size + 1, sizeof(*refs));
6575         if (!refs)
6576                 return ERR;
6578         ref = &refs[refs_size++];
6579         ref->name = malloc(namelen + 1);
6580         if (!ref->name)
6581                 return ERR;
6583         strncpy(ref->name, name, namelen);
6584         ref->name[namelen] = 0;
6585         ref->head = head;
6586         ref->tag = tag;
6587         ref->ltag = ltag;
6588         ref->remote = remote;
6589         ref->tracked = tracked;
6590         string_copy_rev(ref->id, id);
6592         return OK;
6595 static int
6596 load_refs(void)
6598         static const char *ls_remote_argv[SIZEOF_ARG] = {
6599                 "git", "ls-remote", ".", NULL
6600         };
6601         static bool init = FALSE;
6603         if (!init) {
6604                 argv_from_env(ls_remote_argv, "TIG_LS_REMOTE");
6605                 init = TRUE;
6606         }
6608         if (!*opt_git_dir)
6609                 return OK;
6611         while (refs_size > 0)
6612                 free(refs[--refs_size].name);
6613         while (id_refs_size > 0)
6614                 free(id_refs[--id_refs_size]);
6616         return run_io_load(ls_remote_argv, "\t", read_ref);
6619 static int
6620 read_repo_config_option(char *name, size_t namelen, char *value, size_t valuelen)
6622         if (!strcmp(name, "i18n.commitencoding"))
6623                 string_ncopy(opt_encoding, value, valuelen);
6625         if (!strcmp(name, "core.editor"))
6626                 string_ncopy(opt_editor, value, valuelen);
6628         /* branch.<head>.remote */
6629         if (*opt_head &&
6630             !strncmp(name, "branch.", 7) &&
6631             !strncmp(name + 7, opt_head, strlen(opt_head)) &&
6632             !strcmp(name + 7 + strlen(opt_head), ".remote"))
6633                 string_ncopy(opt_remote, value, valuelen);
6635         if (*opt_head && *opt_remote &&
6636             !strncmp(name, "branch.", 7) &&
6637             !strncmp(name + 7, opt_head, strlen(opt_head)) &&
6638             !strcmp(name + 7 + strlen(opt_head), ".merge")) {
6639                 size_t from = strlen(opt_remote);
6641                 if (!prefixcmp(value, "refs/heads/")) {
6642                         value += STRING_SIZE("refs/heads/");
6643                         valuelen -= STRING_SIZE("refs/heads/");
6644                 }
6646                 if (!string_format_from(opt_remote, &from, "/%s", value))
6647                         opt_remote[0] = 0;
6648         }
6650         return OK;
6653 static int
6654 load_git_config(void)
6656         const char *config_list_argv[] = { "git", GIT_CONFIG, "--list", NULL };
6658         return run_io_load(config_list_argv, "=", read_repo_config_option);
6661 static int
6662 read_repo_info(char *name, size_t namelen, char *value, size_t valuelen)
6664         if (!opt_git_dir[0]) {
6665                 string_ncopy(opt_git_dir, name, namelen);
6667         } else if (opt_is_inside_work_tree == -1) {
6668                 /* This can be 3 different values depending on the
6669                  * version of git being used. If git-rev-parse does not
6670                  * understand --is-inside-work-tree it will simply echo
6671                  * the option else either "true" or "false" is printed.
6672                  * Default to true for the unknown case. */
6673                 opt_is_inside_work_tree = strcmp(name, "false") ? TRUE : FALSE;
6675         } else if (*name == '.') {
6676                 string_ncopy(opt_cdup, name, namelen);
6678         } else {
6679                 string_ncopy(opt_prefix, name, namelen);
6680         }
6682         return OK;
6685 static int
6686 load_repo_info(void)
6688         const char *head_argv[] = {
6689                 "git", "symbolic-ref", "HEAD", NULL
6690         };
6691         const char *rev_parse_argv[] = {
6692                 "git", "rev-parse", "--git-dir", "--is-inside-work-tree",
6693                         "--show-cdup", "--show-prefix", NULL
6694         };
6696         if (run_io_buf(head_argv, opt_head, sizeof(opt_head))) {
6697                 chomp_string(opt_head);
6698                 if (!prefixcmp(opt_head, "refs/heads/")) {
6699                         char *offset = opt_head + STRING_SIZE("refs/heads/");
6701                         memmove(opt_head, offset, strlen(offset) + 1);
6702                 }
6703         }
6705         return run_io_load(rev_parse_argv, "=", read_repo_info);
6709 /*
6710  * Main
6711  */
6713 static void __NORETURN
6714 quit(int sig)
6716         /* XXX: Restore tty modes and let the OS cleanup the rest! */
6717         if (cursed)
6718                 endwin();
6719         exit(0);
6722 static void __NORETURN
6723 die(const char *err, ...)
6725         va_list args;
6727         endwin();
6729         va_start(args, err);
6730         fputs("tig: ", stderr);
6731         vfprintf(stderr, err, args);
6732         fputs("\n", stderr);
6733         va_end(args);
6735         exit(1);
6738 static void
6739 warn(const char *msg, ...)
6741         va_list args;
6743         va_start(args, msg);
6744         fputs("tig warning: ", stderr);
6745         vfprintf(stderr, msg, args);
6746         fputs("\n", stderr);
6747         va_end(args);
6750 static enum request
6751 parse_options(int argc, const char *argv[])
6753         enum request request = REQ_VIEW_MAIN;
6754         const char *subcommand;
6755         bool seen_dashdash = FALSE;
6756         /* XXX: This is vulnerable to the user overriding options
6757          * required for the main view parser. */
6758         const char *custom_argv[SIZEOF_ARG] = {
6759                 "git", "log", "--no-color", "--pretty=raw", "--parents",
6760                         "--topo-order", NULL
6761         };
6762         int i, j = 6;
6764         if (!isatty(STDIN_FILENO)) {
6765                 io_open(&VIEW(REQ_VIEW_PAGER)->io, "");
6766                 return REQ_VIEW_PAGER;
6767         }
6769         if (argc <= 1)
6770                 return REQ_NONE;
6772         subcommand = argv[1];
6773         if (!strcmp(subcommand, "status")) {
6774                 if (argc > 2)
6775                         warn("ignoring arguments after `%s'", subcommand);
6776                 return REQ_VIEW_STATUS;
6778         } else if (!strcmp(subcommand, "blame")) {
6779                 if (argc <= 2 || argc > 4)
6780                         die("invalid number of options to blame\n\n%s", usage);
6782                 i = 2;
6783                 if (argc == 4) {
6784                         string_ncopy(opt_ref, argv[i], strlen(argv[i]));
6785                         i++;
6786                 }
6788                 string_ncopy(opt_file, argv[i], strlen(argv[i]));
6789                 return REQ_VIEW_BLAME;
6791         } else if (!strcmp(subcommand, "show")) {
6792                 request = REQ_VIEW_DIFF;
6794         } else {
6795                 subcommand = NULL;
6796         }
6798         if (subcommand) {
6799                 custom_argv[1] = subcommand;
6800                 j = 2;
6801         }
6803         for (i = 1 + !!subcommand; i < argc; i++) {
6804                 const char *opt = argv[i];
6806                 if (seen_dashdash || !strcmp(opt, "--")) {
6807                         seen_dashdash = TRUE;
6809                 } else if (!strcmp(opt, "-v") || !strcmp(opt, "--version")) {
6810                         printf("tig version %s\n", TIG_VERSION);
6811                         quit(0);
6813                 } else if (!strcmp(opt, "-h") || !strcmp(opt, "--help")) {
6814                         printf("%s\n", usage);
6815                         quit(0);
6816                 }
6818                 custom_argv[j++] = opt;
6819                 if (j >= ARRAY_SIZE(custom_argv))
6820                         die("command too long");
6821         }
6823         if (!prepare_update(VIEW(request), custom_argv, NULL, FORMAT_NONE))                                                                        
6824                 die("Failed to format arguments"); 
6826         return request;
6829 int
6830 main(int argc, const char *argv[])
6832         enum request request = parse_options(argc, argv);
6833         struct view *view;
6834         size_t i;
6836         signal(SIGINT, quit);
6838         if (setlocale(LC_ALL, "")) {
6839                 char *codeset = nl_langinfo(CODESET);
6841                 string_ncopy(opt_codeset, codeset, strlen(codeset));
6842         }
6844         if (load_repo_info() == ERR)
6845                 die("Failed to load repo info.");
6847         if (load_options() == ERR)
6848                 die("Failed to load user config.");
6850         if (load_git_config() == ERR)
6851                 die("Failed to load repo config.");
6853         /* Require a git repository unless when running in pager mode. */
6854         if (!opt_git_dir[0] && request != REQ_VIEW_PAGER)
6855                 die("Not a git repository");
6857         if (*opt_encoding && strcasecmp(opt_encoding, "UTF-8"))
6858                 opt_utf8 = FALSE;
6860         if (*opt_codeset && strcmp(opt_codeset, opt_encoding)) {
6861                 opt_iconv = iconv_open(opt_codeset, opt_encoding);
6862                 if (opt_iconv == ICONV_NONE)
6863                         die("Failed to initialize character set conversion");
6864         }
6866         if (load_refs() == ERR)
6867                 die("Failed to load refs.");
6869         foreach_view (view, i)
6870                 argv_from_env(view->ops->argv, view->cmd_env);
6872         init_display();
6874         if (request != REQ_NONE)
6875                 open_view(NULL, request, OPEN_PREPARED);
6876         request = request == REQ_NONE ? REQ_VIEW_MAIN : REQ_NONE;
6878         while (view_driver(display[current_view], request)) {
6879                 int key = get_input(0);
6881                 view = display[current_view];
6882                 request = get_keybinding(view->keymap, key);
6884                 /* Some low-level request handling. This keeps access to
6885                  * status_win restricted. */
6886                 switch (request) {
6887                 case REQ_PROMPT:
6888                 {
6889                         char *cmd = read_prompt(":");
6891                         if (cmd) {
6892                                 struct view *next = VIEW(REQ_VIEW_PAGER);
6893                                 const char *argv[SIZEOF_ARG] = { "git" };
6894                                 int argc = 1;
6896                                 /* When running random commands, initially show the
6897                                  * command in the title. However, it maybe later be
6898                                  * overwritten if a commit line is selected. */
6899                                 string_ncopy(next->ref, cmd, strlen(cmd));
6901                                 if (!argv_from_string(argv, &argc, cmd)) {
6902                                         report("Too many arguments");
6903                                 } else if (!prepare_update(next, argv, NULL, FORMAT_DASH)) {
6904                                         report("Failed to format command");
6905                                 } else {
6906                                         open_view(view, REQ_VIEW_PAGER, OPEN_PREPARED);
6907                                 }
6908                         }
6910                         request = REQ_NONE;
6911                         break;
6912                 }
6913                 case REQ_SEARCH:
6914                 case REQ_SEARCH_BACK:
6915                 {
6916                         const char *prompt = request == REQ_SEARCH ? "/" : "?";
6917                         char *search = read_prompt(prompt);
6919                         if (search)
6920                                 string_ncopy(opt_search, search, strlen(search));
6921                         else if (*opt_search)
6922                                 request = request == REQ_SEARCH ?
6923                                         REQ_FIND_NEXT :
6924                                         REQ_FIND_PREV;
6925                         else
6926                                 request = REQ_NONE;
6927                         break;
6928                 }
6929                 default:
6930                         break;
6931                 }
6932         }
6934         quit(0);
6936         return 0;