Code

Add view flag with information about whether the view supports refreshing
[tig.git] / tig.c
1 /* Copyright (c) 2006-2010 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 <sys/time.h>
40 #include <time.h>
41 #include <fcntl.h>
43 #include <regex.h>
45 #include <locale.h>
46 #include <langinfo.h>
47 #include <iconv.h>
49 /* ncurses(3): Must be defined to have extended wide-character functions. */
50 #define _XOPEN_SOURCE_EXTENDED
52 #ifdef HAVE_NCURSESW_NCURSES_H
53 #include <ncursesw/ncurses.h>
54 #else
55 #ifdef HAVE_NCURSES_NCURSES_H
56 #include <ncurses/ncurses.h>
57 #else
58 #include <ncurses.h>
59 #endif
60 #endif
62 #if __GNUC__ >= 3
63 #define __NORETURN __attribute__((__noreturn__))
64 #else
65 #define __NORETURN
66 #endif
68 static void __NORETURN die(const char *err, ...);
69 static void warn(const char *msg, ...);
70 static void report(const char *msg, ...);
72 #define ABS(x)          ((x) >= 0  ? (x) : -(x))
73 #define MIN(x, y)       ((x) < (y) ? (x) :  (y))
74 #define MAX(x, y)       ((x) > (y) ? (x) :  (y))
76 #define ARRAY_SIZE(x)   (sizeof(x) / sizeof(x[0]))
77 #define STRING_SIZE(x)  (sizeof(x) - 1)
79 #define SIZEOF_STR      1024    /* Default string size. */
80 #define SIZEOF_REF      256     /* Size of symbolic or SHA1 ID. */
81 #define SIZEOF_REV      41      /* Holds a SHA-1 and an ending NUL. */
82 #define SIZEOF_ARG      32      /* Default argument array size. */
84 /* Revision graph */
86 #define REVGRAPH_INIT   'I'
87 #define REVGRAPH_MERGE  'M'
88 #define REVGRAPH_BRANCH '+'
89 #define REVGRAPH_COMMIT '*'
90 #define REVGRAPH_BOUND  '^'
92 #define SIZEOF_REVGRAPH 19      /* Size of revision ancestry graphics. */
94 /* This color name can be used to refer to the default term colors. */
95 #define COLOR_DEFAULT   (-1)
97 #define ICONV_NONE      ((iconv_t) -1)
98 #ifndef ICONV_CONST
99 #define ICONV_CONST     /* nothing */
100 #endif
102 /* The format and size of the date column in the main view. */
103 #define DATE_FORMAT     "%Y-%m-%d %H:%M"
104 #define DATE_COLS       STRING_SIZE("2006-04-29 14:21 ")
105 #define DATE_SHORT_COLS STRING_SIZE("2006-04-29 ")
107 #define ID_COLS         8
108 #define AUTHOR_COLS     19
110 #define MIN_VIEW_HEIGHT 4
112 #define NULL_ID         "0000000000000000000000000000000000000000"
114 #define S_ISGITLINK(mode) (((mode) & S_IFMT) == 0160000)
116 /* Some ASCII-shorthands fitted into the ncurses namespace. */
117 #define KEY_TAB         '\t'
118 #define KEY_RETURN      '\r'
119 #define KEY_ESC         27
122 struct ref {
123         char id[SIZEOF_REV];    /* Commit SHA1 ID */
124         unsigned int head:1;    /* Is it the current HEAD? */
125         unsigned int tag:1;     /* Is it a tag? */
126         unsigned int ltag:1;    /* If so, is the tag local? */
127         unsigned int remote:1;  /* Is it a remote ref? */
128         unsigned int tracked:1; /* Is it the remote for the current HEAD? */
129         char name[1];           /* Ref name; tag or head names are shortened. */
130 };
132 struct ref_list {
133         char id[SIZEOF_REV];    /* Commit SHA1 ID */
134         size_t size;            /* Number of refs. */
135         struct ref **refs;      /* References for this ID. */
136 };
138 static struct ref *get_ref_head();
139 static struct ref_list *get_ref_list(const char *id);
140 static void foreach_ref(bool (*visitor)(void *data, const struct ref *ref), void *data);
141 static int load_refs(void);
143 enum format_flags {
144         FORMAT_ALL,             /* Perform replacement in all arguments. */
145         FORMAT_NONE             /* No replacement should be performed. */
146 };
148 static bool format_argv(const char *dst[], const char *src[], enum format_flags flags);
150 enum input_status {
151         INPUT_OK,
152         INPUT_SKIP,
153         INPUT_STOP,
154         INPUT_CANCEL
155 };
157 typedef enum input_status (*input_handler)(void *data, char *buf, int c);
159 static char *prompt_input(const char *prompt, input_handler handler, void *data);
160 static bool prompt_yesno(const char *prompt);
162 struct menu_item {
163         int hotkey;
164         const char *text;
165         void *data;
166 };
168 static bool prompt_menu(const char *prompt, const struct menu_item *items, int *selected);
170 /*
171  * Allocation helpers ... Entering macro hell to never be seen again.
172  */
174 #define DEFINE_ALLOCATOR(name, type, chunk_size)                                \
175 static type *                                                                   \
176 name(type **mem, size_t size, size_t increase)                                  \
177 {                                                                               \
178         size_t num_chunks = (size + chunk_size - 1) / chunk_size;               \
179         size_t num_chunks_new = (size + increase + chunk_size - 1) / chunk_size;\
180         type *tmp = *mem;                                                       \
181                                                                                 \
182         if (mem == NULL || num_chunks != num_chunks_new) {                      \
183                 tmp = realloc(tmp, num_chunks_new * chunk_size * sizeof(type)); \
184                 if (tmp)                                                        \
185                         *mem = tmp;                                             \
186         }                                                                       \
187                                                                                 \
188         return tmp;                                                             \
191 /*
192  * String helpers
193  */
195 static inline void
196 string_ncopy_do(char *dst, size_t dstlen, const char *src, size_t srclen)
198         if (srclen > dstlen - 1)
199                 srclen = dstlen - 1;
201         strncpy(dst, src, srclen);
202         dst[srclen] = 0;
205 /* Shorthands for safely copying into a fixed buffer. */
207 #define string_copy(dst, src) \
208         string_ncopy_do(dst, sizeof(dst), src, sizeof(src))
210 #define string_ncopy(dst, src, srclen) \
211         string_ncopy_do(dst, sizeof(dst), src, srclen)
213 #define string_copy_rev(dst, src) \
214         string_ncopy_do(dst, SIZEOF_REV, src, SIZEOF_REV - 1)
216 #define string_add(dst, from, src) \
217         string_ncopy_do(dst + (from), sizeof(dst) - (from), src, sizeof(src))
219 static void
220 string_expand(char *dst, size_t dstlen, const char *src, int tabsize)
222         size_t size, pos;
224         for (size = pos = 0; size < dstlen - 1 && src[pos]; pos++) {
225                 if (src[pos] == '\t') {
226                         size_t expanded = tabsize - (size % tabsize);
228                         if (expanded + size >= dstlen - 1)
229                                 expanded = dstlen - size - 1;
230                         memcpy(dst + size, "        ", expanded);
231                         size += expanded;
232                 } else {
233                         dst[size++] = src[pos];
234                 }
235         }
237         dst[size] = 0;
240 static char *
241 chomp_string(char *name)
243         int namelen;
245         while (isspace(*name))
246                 name++;
248         namelen = strlen(name) - 1;
249         while (namelen > 0 && isspace(name[namelen]))
250                 name[namelen--] = 0;
252         return name;
255 static bool
256 string_nformat(char *buf, size_t bufsize, size_t *bufpos, const char *fmt, ...)
258         va_list args;
259         size_t pos = bufpos ? *bufpos : 0;
261         va_start(args, fmt);
262         pos += vsnprintf(buf + pos, bufsize - pos, fmt, args);
263         va_end(args);
265         if (bufpos)
266                 *bufpos = pos;
268         return pos >= bufsize ? FALSE : TRUE;
271 #define string_format(buf, fmt, args...) \
272         string_nformat(buf, sizeof(buf), NULL, fmt, args)
274 #define string_format_from(buf, from, fmt, args...) \
275         string_nformat(buf, sizeof(buf), from, fmt, args)
277 static int
278 string_enum_compare(const char *str1, const char *str2, int len)
280         size_t i;
282 #define string_enum_sep(x) ((x) == '-' || (x) == '_' || (x) == '.')
284         /* Diff-Header == DIFF_HEADER */
285         for (i = 0; i < len; i++) {
286                 if (toupper(str1[i]) == toupper(str2[i]))
287                         continue;
289                 if (string_enum_sep(str1[i]) &&
290                     string_enum_sep(str2[i]))
291                         continue;
293                 return str1[i] - str2[i];
294         }
296         return 0;
299 #define enum_equals(entry, str, len) \
300         ((entry).namelen == (len) && !string_enum_compare((entry).name, str, len))
302 struct enum_map {
303         const char *name;
304         int namelen;
305         int value;
306 };
308 #define ENUM_MAP(name, value) { name, STRING_SIZE(name), value }
310 static char *
311 enum_map_name(const char *name, size_t namelen)
313         static char buf[SIZEOF_STR];
314         int bufpos;
316         for (bufpos = 0; bufpos <= namelen; bufpos++) {
317                 buf[bufpos] = tolower(name[bufpos]);
318                 if (buf[bufpos] == '_')
319                         buf[bufpos] = '-';
320         }
322         buf[bufpos] = 0;
323         return buf;
326 #define enum_name(entry) enum_map_name((entry).name, (entry).namelen)
328 static bool
329 map_enum_do(const struct enum_map *map, size_t map_size, int *value, const char *name)
331         size_t namelen = strlen(name);
332         int i;
334         for (i = 0; i < map_size; i++)
335                 if (enum_equals(map[i], name, namelen)) {
336                         *value = map[i].value;
337                         return TRUE;
338                 }
340         return FALSE;
343 #define map_enum(attr, map, name) \
344         map_enum_do(map, ARRAY_SIZE(map), attr, name)
346 #define prefixcmp(str1, str2) \
347         strncmp(str1, str2, STRING_SIZE(str2))
349 static inline int
350 suffixcmp(const char *str, int slen, const char *suffix)
352         size_t len = slen >= 0 ? slen : strlen(str);
353         size_t suffixlen = strlen(suffix);
355         return suffixlen < len ? strcmp(str + len - suffixlen, suffix) : -1;
359 /*
360  * Unicode / UTF-8 handling
361  *
362  * NOTE: Much of the following code for dealing with Unicode is derived from
363  * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
364  * src/intl/charset.c from the UTF-8 branch commit elinks-0.11.0-g31f2c28.
365  */
367 static inline int
368 unicode_width(unsigned long c, int tab_size)
370         if (c >= 0x1100 &&
371            (c <= 0x115f                         /* Hangul Jamo */
372             || c == 0x2329
373             || c == 0x232a
374             || (c >= 0x2e80  && c <= 0xa4cf && c != 0x303f)
375                                                 /* CJK ... Yi */
376             || (c >= 0xac00  && c <= 0xd7a3)    /* Hangul Syllables */
377             || (c >= 0xf900  && c <= 0xfaff)    /* CJK Compatibility Ideographs */
378             || (c >= 0xfe30  && c <= 0xfe6f)    /* CJK Compatibility Forms */
379             || (c >= 0xff00  && c <= 0xff60)    /* Fullwidth Forms */
380             || (c >= 0xffe0  && c <= 0xffe6)
381             || (c >= 0x20000 && c <= 0x2fffd)
382             || (c >= 0x30000 && c <= 0x3fffd)))
383                 return 2;
385         if (c == '\t')
386                 return tab_size;
388         return 1;
391 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
392  * Illegal bytes are set one. */
393 static const unsigned char utf8_bytes[256] = {
394         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,
395         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,
396         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,
397         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,
398         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,
399         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,
400         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,
401         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,
402 };
404 static inline unsigned char
405 utf8_char_length(const char *string, const char *end)
407         int c = *(unsigned char *) string;
409         return utf8_bytes[c];
412 /* Decode UTF-8 multi-byte representation into a Unicode character. */
413 static inline unsigned long
414 utf8_to_unicode(const char *string, size_t length)
416         unsigned long unicode;
418         switch (length) {
419         case 1:
420                 unicode  =   string[0];
421                 break;
422         case 2:
423                 unicode  =  (string[0] & 0x1f) << 6;
424                 unicode +=  (string[1] & 0x3f);
425                 break;
426         case 3:
427                 unicode  =  (string[0] & 0x0f) << 12;
428                 unicode += ((string[1] & 0x3f) << 6);
429                 unicode +=  (string[2] & 0x3f);
430                 break;
431         case 4:
432                 unicode  =  (string[0] & 0x0f) << 18;
433                 unicode += ((string[1] & 0x3f) << 12);
434                 unicode += ((string[2] & 0x3f) << 6);
435                 unicode +=  (string[3] & 0x3f);
436                 break;
437         case 5:
438                 unicode  =  (string[0] & 0x0f) << 24;
439                 unicode += ((string[1] & 0x3f) << 18);
440                 unicode += ((string[2] & 0x3f) << 12);
441                 unicode += ((string[3] & 0x3f) << 6);
442                 unicode +=  (string[4] & 0x3f);
443                 break;
444         case 6:
445                 unicode  =  (string[0] & 0x01) << 30;
446                 unicode += ((string[1] & 0x3f) << 24);
447                 unicode += ((string[2] & 0x3f) << 18);
448                 unicode += ((string[3] & 0x3f) << 12);
449                 unicode += ((string[4] & 0x3f) << 6);
450                 unicode +=  (string[5] & 0x3f);
451                 break;
452         default:
453                 return 0;
454         }
456         /* Invalid characters could return the special 0xfffd value but NUL
457          * should be just as good. */
458         return unicode > 0xffff ? 0 : unicode;
461 /* Calculates how much of string can be shown within the given maximum width
462  * and sets trimmed parameter to non-zero value if all of string could not be
463  * shown. If the reserve flag is TRUE, it will reserve at least one
464  * trailing character, which can be useful when drawing a delimiter.
465  *
466  * Returns the number of bytes to output from string to satisfy max_width. */
467 static size_t
468 utf8_length(const char **start, size_t skip, int *width, size_t max_width, int *trimmed, bool reserve, int tab_size)
470         const char *string = *start;
471         const char *end = strchr(string, '\0');
472         unsigned char last_bytes = 0;
473         size_t last_ucwidth = 0;
475         *width = 0;
476         *trimmed = 0;
478         while (string < end) {
479                 unsigned char bytes = utf8_char_length(string, end);
480                 size_t ucwidth;
481                 unsigned long unicode;
483                 if (string + bytes > end)
484                         break;
486                 /* Change representation to figure out whether
487                  * it is a single- or double-width character. */
489                 unicode = utf8_to_unicode(string, bytes);
490                 /* FIXME: Graceful handling of invalid Unicode character. */
491                 if (!unicode)
492                         break;
494                 ucwidth = unicode_width(unicode, tab_size);
495                 if (skip > 0) {
496                         skip -= ucwidth <= skip ? ucwidth : skip;
497                         *start += bytes;
498                 }
499                 *width  += ucwidth;
500                 if (*width > max_width) {
501                         *trimmed = 1;
502                         *width -= ucwidth;
503                         if (reserve && *width == max_width) {
504                                 string -= last_bytes;
505                                 *width -= last_ucwidth;
506                         }
507                         break;
508                 }
510                 string  += bytes;
511                 last_bytes = ucwidth ? bytes : 0;
512                 last_ucwidth = ucwidth;
513         }
515         return string - *start;
519 #define DATE_INFO \
520         DATE_(NO), \
521         DATE_(DEFAULT), \
522         DATE_(RELATIVE), \
523         DATE_(SHORT)
525 enum date {
526 #define DATE_(name) DATE_##name
527         DATE_INFO
528 #undef  DATE_
529 };
531 static const struct enum_map date_map[] = {
532 #define DATE_(name) ENUM_MAP(#name, DATE_##name)
533         DATE_INFO
534 #undef  DATE_
535 };
537 struct time {
538         time_t sec;
539         int tz;
540 };
542 static inline int timecmp(const struct time *t1, const struct time *t2)
544         return t1->sec - t2->sec;
547 static const char *
548 mkdate(const struct time *time, enum date date)
550         static char buf[DATE_COLS + 1];
551         static const struct enum_map reldate[] = {
552                 { "second", 1,                  60 * 2 },
553                 { "minute", 60,                 60 * 60 * 2 },
554                 { "hour",   60 * 60,            60 * 60 * 24 * 2 },
555                 { "day",    60 * 60 * 24,       60 * 60 * 24 * 7 * 2 },
556                 { "week",   60 * 60 * 24 * 7,   60 * 60 * 24 * 7 * 5 },
557                 { "month",  60 * 60 * 24 * 30,  60 * 60 * 24 * 30 * 12 },
558         };
559         struct tm tm;
561         if (!date || !time || !time->sec)
562                 return "";
564         if (date == DATE_RELATIVE) {
565                 struct timeval now;
566                 time_t date = time->sec + time->tz;
567                 time_t seconds;
568                 int i;
570                 gettimeofday(&now, NULL);
571                 seconds = now.tv_sec < date ? date - now.tv_sec : now.tv_sec - date;
572                 for (i = 0; i < ARRAY_SIZE(reldate); i++) {
573                         if (seconds >= reldate[i].value)
574                                 continue;
576                         seconds /= reldate[i].namelen;
577                         if (!string_format(buf, "%ld %s%s %s",
578                                            seconds, reldate[i].name,
579                                            seconds > 1 ? "s" : "",
580                                            now.tv_sec >= date ? "ago" : "ahead"))
581                                 break;
582                         return buf;
583                 }
584         }
586         gmtime_r(&time->sec, &tm);
587         return strftime(buf, sizeof(buf), DATE_FORMAT, &tm) ? buf : NULL;
591 #define AUTHOR_VALUES \
592         AUTHOR_(NO), \
593         AUTHOR_(FULL), \
594         AUTHOR_(ABBREVIATED)
596 enum author {
597 #define AUTHOR_(name) AUTHOR_##name
598         AUTHOR_VALUES,
599 #undef  AUTHOR_
600         AUTHOR_DEFAULT = AUTHOR_FULL
601 };
603 static const struct enum_map author_map[] = {
604 #define AUTHOR_(name) ENUM_MAP(#name, AUTHOR_##name)
605         AUTHOR_VALUES
606 #undef  AUTHOR_
607 };
609 static const char *
610 get_author_initials(const char *author)
612         static char initials[AUTHOR_COLS * 6 + 1];
613         size_t pos = 0;
614         const char *end = strchr(author, '\0');
616 #define is_initial_sep(c) (isspace(c) || ispunct(c) || (c) == '@' || (c) == '-')
618         memset(initials, 0, sizeof(initials));
619         while (author < end) {
620                 unsigned char bytes;
621                 size_t i;
623                 while (is_initial_sep(*author))
624                         author++;
626                 bytes = utf8_char_length(author, end);
627                 if (bytes < sizeof(initials) - 1 - pos) {
628                         while (bytes--) {
629                                 initials[pos++] = *author++;
630                         }
631                 }
633                 for (i = pos; author < end && !is_initial_sep(*author); author++) {
634                         if (i < sizeof(initials) - 1)
635                                 initials[i++] = *author;
636                 }
638                 initials[i++] = 0;
639         }
641         return initials;
645 static bool
646 argv_from_string(const char *argv[SIZEOF_ARG], int *argc, char *cmd)
648         int valuelen;
650         while (*cmd && *argc < SIZEOF_ARG && (valuelen = strcspn(cmd, " \t"))) {
651                 bool advance = cmd[valuelen] != 0;
653                 cmd[valuelen] = 0;
654                 argv[(*argc)++] = chomp_string(cmd);
655                 cmd = chomp_string(cmd + valuelen + advance);
656         }
658         if (*argc < SIZEOF_ARG)
659                 argv[*argc] = NULL;
660         return *argc < SIZEOF_ARG;
663 static bool
664 argv_from_env(const char **argv, const char *name)
666         char *env = argv ? getenv(name) : NULL;
667         int argc = 0;
669         if (env && *env)
670                 env = strdup(env);
671         return !env || argv_from_string(argv, &argc, env);
675 /*
676  * Executing external commands.
677  */
679 enum io_type {
680         IO_FD,                  /* File descriptor based IO. */
681         IO_BG,                  /* Execute command in the background. */
682         IO_FG,                  /* Execute command with same std{in,out,err}. */
683         IO_RD,                  /* Read only fork+exec IO. */
684         IO_WR,                  /* Write only fork+exec IO. */
685         IO_AP,                  /* Append fork+exec output to file. */
686 };
688 struct io {
689         enum io_type type;      /* The requested type of pipe. */
690         const char *dir;        /* Directory from which to execute. */
691         pid_t pid;              /* PID of spawned process. */
692         int pipe;               /* Pipe end for reading or writing. */
693         int error;              /* Error status. */
694         const char *argv[SIZEOF_ARG];   /* Shell command arguments. */
695         char *buf;              /* Read buffer. */
696         size_t bufalloc;        /* Allocated buffer size. */
697         size_t bufsize;         /* Buffer content size. */
698         char *bufpos;           /* Current buffer position. */
699         unsigned int eof:1;     /* Has end of file been reached. */
700 };
702 static void
703 io_reset(struct io *io)
705         io->pipe = -1;
706         io->pid = 0;
707         io->buf = io->bufpos = NULL;
708         io->bufalloc = io->bufsize = 0;
709         io->error = 0;
710         io->eof = 0;
713 static void
714 io_init(struct io *io, const char *dir, enum io_type type)
716         io_reset(io);
717         io->type = type;
718         io->dir = dir;
721 static bool
722 io_format(struct io *io, const char *dir, enum io_type type,
723           const char *argv[], enum format_flags flags)
725         io_init(io, dir, type);
726         return format_argv(io->argv, argv, flags);
729 static bool
730 io_open(struct io *io, const char *fmt, ...)
732         char name[SIZEOF_STR] = "";
733         bool fits;
734         va_list args;
736         io_init(io, NULL, IO_FD);
738         va_start(args, fmt);
739         fits = vsnprintf(name, sizeof(name), fmt, args) < sizeof(name);
740         va_end(args);
742         if (!fits) {
743                 io->error = ENAMETOOLONG;
744                 return FALSE;
745         }
746         io->pipe = *name ? open(name, O_RDONLY) : STDIN_FILENO;
747         if (io->pipe == -1)
748                 io->error = errno;
749         return io->pipe != -1;
752 static bool
753 io_kill(struct io *io)
755         return io->pid == 0 || kill(io->pid, SIGKILL) != -1;
758 static bool
759 io_done(struct io *io)
761         pid_t pid = io->pid;
763         if (io->pipe != -1)
764                 close(io->pipe);
765         free(io->buf);
766         io_reset(io);
768         while (pid > 0) {
769                 int status;
770                 pid_t waiting = waitpid(pid, &status, 0);
772                 if (waiting < 0) {
773                         if (errno == EINTR)
774                                 continue;
775                         io->error = errno;
776                         return FALSE;
777                 }
779                 return waiting == pid &&
780                        !WIFSIGNALED(status) &&
781                        WIFEXITED(status) &&
782                        !WEXITSTATUS(status);
783         }
785         return TRUE;
788 static bool
789 io_start(struct io *io)
791         int pipefds[2] = { -1, -1 };
793         if (io->type == IO_FD)
794                 return TRUE;
796         if ((io->type == IO_RD || io->type == IO_WR) && pipe(pipefds) < 0) {
797                 io->error = errno;
798                 return FALSE;
799         } else if (io->type == IO_AP) {
800                 pipefds[1] = io->pipe;
801         }
803         if ((io->pid = fork())) {
804                 if (io->pid == -1)
805                         io->error = errno;
806                 if (pipefds[!(io->type == IO_WR)] != -1)
807                         close(pipefds[!(io->type == IO_WR)]);
808                 if (io->pid != -1) {
809                         io->pipe = pipefds[!!(io->type == IO_WR)];
810                         return TRUE;
811                 }
813         } else {
814                 if (io->type != IO_FG) {
815                         int devnull = open("/dev/null", O_RDWR);
816                         int readfd  = io->type == IO_WR ? pipefds[0] : devnull;
817                         int writefd = (io->type == IO_RD || io->type == IO_AP)
818                                                         ? pipefds[1] : devnull;
820                         dup2(readfd,  STDIN_FILENO);
821                         dup2(writefd, STDOUT_FILENO);
822                         dup2(devnull, STDERR_FILENO);
824                         close(devnull);
825                         if (pipefds[0] != -1)
826                                 close(pipefds[0]);
827                         if (pipefds[1] != -1)
828                                 close(pipefds[1]);
829                 }
831                 if (io->dir && *io->dir && chdir(io->dir) == -1)
832                         exit(errno);
834                 execvp(io->argv[0], (char *const*) io->argv);
835                 exit(errno);
836         }
838         if (pipefds[!!(io->type == IO_WR)] != -1)
839                 close(pipefds[!!(io->type == IO_WR)]);
840         return FALSE;
843 static bool
844 io_run(struct io *io, const char **argv, const char *dir, enum io_type type)
846         io_init(io, dir, type);
847         if (!format_argv(io->argv, argv, FORMAT_NONE))
848                 return FALSE;
849         return io_start(io);
852 static int
853 io_complete(struct io *io)
855         return io_start(io) && io_done(io);
858 static int
859 io_run_bg(const char **argv)
861         struct io io = {};
863         if (!io_format(&io, NULL, IO_BG, argv, FORMAT_NONE))
864                 return FALSE;
865         return io_complete(&io);
868 static bool
869 io_run_fg(const char **argv, const char *dir)
871         struct io io = {};
873         if (!io_format(&io, dir, IO_FG, argv, FORMAT_NONE))
874                 return FALSE;
875         return io_complete(&io);
878 static bool
879 io_run_append(const char **argv, enum format_flags flags, int fd)
881         struct io io = {};
883         if (!io_format(&io, NULL, IO_AP, argv, flags)) {
884                 close(fd);
885                 return FALSE;
886         }
888         io.pipe = fd;
889         return io_complete(&io);
892 static bool
893 io_run_rd(struct io *io, const char **argv, const char *dir, enum format_flags flags)
895         return io_format(io, dir, IO_RD, argv, flags) && io_start(io);
898 static bool
899 io_eof(struct io *io)
901         return io->eof;
904 static int
905 io_error(struct io *io)
907         return io->error;
910 static char *
911 io_strerror(struct io *io)
913         return strerror(io->error);
916 static bool
917 io_can_read(struct io *io)
919         struct timeval tv = { 0, 500 };
920         fd_set fds;
922         FD_ZERO(&fds);
923         FD_SET(io->pipe, &fds);
925         return select(io->pipe + 1, &fds, NULL, NULL, &tv) > 0;
928 static ssize_t
929 io_read(struct io *io, void *buf, size_t bufsize)
931         do {
932                 ssize_t readsize = read(io->pipe, buf, bufsize);
934                 if (readsize < 0 && (errno == EAGAIN || errno == EINTR))
935                         continue;
936                 else if (readsize == -1)
937                         io->error = errno;
938                 else if (readsize == 0)
939                         io->eof = 1;
940                 return readsize;
941         } while (1);
944 DEFINE_ALLOCATOR(io_realloc_buf, char, BUFSIZ)
946 static char *
947 io_get(struct io *io, int c, bool can_read)
949         char *eol;
950         ssize_t readsize;
952         while (TRUE) {
953                 if (io->bufsize > 0) {
954                         eol = memchr(io->bufpos, c, io->bufsize);
955                         if (eol) {
956                                 char *line = io->bufpos;
958                                 *eol = 0;
959                                 io->bufpos = eol + 1;
960                                 io->bufsize -= io->bufpos - line;
961                                 return line;
962                         }
963                 }
965                 if (io_eof(io)) {
966                         if (io->bufsize) {
967                                 io->bufpos[io->bufsize] = 0;
968                                 io->bufsize = 0;
969                                 return io->bufpos;
970                         }
971                         return NULL;
972                 }
974                 if (!can_read)
975                         return NULL;
977                 if (io->bufsize > 0 && io->bufpos > io->buf)
978                         memmove(io->buf, io->bufpos, io->bufsize);
980                 if (io->bufalloc == io->bufsize) {
981                         if (!io_realloc_buf(&io->buf, io->bufalloc, BUFSIZ))
982                                 return NULL;
983                         io->bufalloc += BUFSIZ;
984                 }
986                 io->bufpos = io->buf;
987                 readsize = io_read(io, io->buf + io->bufsize, io->bufalloc - io->bufsize);
988                 if (io_error(io))
989                         return NULL;
990                 io->bufsize += readsize;
991         }
994 static bool
995 io_write(struct io *io, const void *buf, size_t bufsize)
997         size_t written = 0;
999         while (!io_error(io) && written < bufsize) {
1000                 ssize_t size;
1002                 size = write(io->pipe, buf + written, bufsize - written);
1003                 if (size < 0 && (errno == EAGAIN || errno == EINTR))
1004                         continue;
1005                 else if (size == -1)
1006                         io->error = errno;
1007                 else
1008                         written += size;
1009         }
1011         return written == bufsize;
1014 static bool
1015 io_read_buf(struct io *io, char buf[], size_t bufsize)
1017         char *result = io_get(io, '\n', TRUE);
1019         if (result) {
1020                 result = chomp_string(result);
1021                 string_ncopy_do(buf, bufsize, result, strlen(result));
1022         }
1024         return io_done(io) && result;
1027 static bool
1028 io_run_buf(const char **argv, char buf[], size_t bufsize)
1030         struct io io = {};
1032         return io_run_rd(&io, argv, NULL, FORMAT_NONE)
1033             && io_read_buf(&io, buf, bufsize);
1036 static int
1037 io_load(struct io *io, const char *separators,
1038         int (*read_property)(char *, size_t, char *, size_t))
1040         char *name;
1041         int state = OK;
1043         if (!io_start(io))
1044                 return ERR;
1046         while (state == OK && (name = io_get(io, '\n', TRUE))) {
1047                 char *value;
1048                 size_t namelen;
1049                 size_t valuelen;
1051                 name = chomp_string(name);
1052                 namelen = strcspn(name, separators);
1054                 if (name[namelen]) {
1055                         name[namelen] = 0;
1056                         value = chomp_string(name + namelen + 1);
1057                         valuelen = strlen(value);
1059                 } else {
1060                         value = "";
1061                         valuelen = 0;
1062                 }
1064                 state = read_property(name, namelen, value, valuelen);
1065         }
1067         if (state != ERR && io_error(io))
1068                 state = ERR;
1069         io_done(io);
1071         return state;
1074 static int
1075 io_run_load(const char **argv, const char *separators,
1076             int (*read_property)(char *, size_t, char *, size_t))
1078         struct io io = {};
1080         return io_format(&io, NULL, IO_RD, argv, FORMAT_NONE)
1081                 ? io_load(&io, separators, read_property) : ERR;
1085 /*
1086  * User requests
1087  */
1089 #define REQ_INFO \
1090         /* XXX: Keep the view request first and in sync with views[]. */ \
1091         REQ_GROUP("View switching") \
1092         REQ_(VIEW_MAIN,         "Show main view"), \
1093         REQ_(VIEW_DIFF,         "Show diff view"), \
1094         REQ_(VIEW_LOG,          "Show log view"), \
1095         REQ_(VIEW_TREE,         "Show tree view"), \
1096         REQ_(VIEW_BLOB,         "Show blob view"), \
1097         REQ_(VIEW_BLAME,        "Show blame view"), \
1098         REQ_(VIEW_BRANCH,       "Show branch view"), \
1099         REQ_(VIEW_HELP,         "Show help page"), \
1100         REQ_(VIEW_PAGER,        "Show pager view"), \
1101         REQ_(VIEW_STATUS,       "Show status view"), \
1102         REQ_(VIEW_STAGE,        "Show stage view"), \
1103         \
1104         REQ_GROUP("View manipulation") \
1105         REQ_(ENTER,             "Enter current line and scroll"), \
1106         REQ_(NEXT,              "Move to next"), \
1107         REQ_(PREVIOUS,          "Move to previous"), \
1108         REQ_(PARENT,            "Move to parent"), \
1109         REQ_(VIEW_NEXT,         "Move focus to next view"), \
1110         REQ_(REFRESH,           "Reload and refresh"), \
1111         REQ_(MAXIMIZE,          "Maximize the current view"), \
1112         REQ_(VIEW_CLOSE,        "Close the current view"), \
1113         REQ_(QUIT,              "Close all views and quit"), \
1114         \
1115         REQ_GROUP("View specific requests") \
1116         REQ_(STATUS_UPDATE,     "Update file status"), \
1117         REQ_(STATUS_REVERT,     "Revert file changes"), \
1118         REQ_(STATUS_MERGE,      "Merge file using external tool"), \
1119         REQ_(STAGE_NEXT,        "Find next chunk to stage"), \
1120         \
1121         REQ_GROUP("Cursor navigation") \
1122         REQ_(MOVE_UP,           "Move cursor one line up"), \
1123         REQ_(MOVE_DOWN,         "Move cursor one line down"), \
1124         REQ_(MOVE_PAGE_DOWN,    "Move cursor one page down"), \
1125         REQ_(MOVE_PAGE_UP,      "Move cursor one page up"), \
1126         REQ_(MOVE_FIRST_LINE,   "Move cursor to first line"), \
1127         REQ_(MOVE_LAST_LINE,    "Move cursor to last line"), \
1128         \
1129         REQ_GROUP("Scrolling") \
1130         REQ_(SCROLL_LEFT,       "Scroll two columns left"), \
1131         REQ_(SCROLL_RIGHT,      "Scroll two columns right"), \
1132         REQ_(SCROLL_LINE_UP,    "Scroll one line up"), \
1133         REQ_(SCROLL_LINE_DOWN,  "Scroll one line down"), \
1134         REQ_(SCROLL_PAGE_UP,    "Scroll one page up"), \
1135         REQ_(SCROLL_PAGE_DOWN,  "Scroll one page down"), \
1136         \
1137         REQ_GROUP("Searching") \
1138         REQ_(SEARCH,            "Search the view"), \
1139         REQ_(SEARCH_BACK,       "Search backwards in the view"), \
1140         REQ_(FIND_NEXT,         "Find next search match"), \
1141         REQ_(FIND_PREV,         "Find previous search match"), \
1142         \
1143         REQ_GROUP("Option manipulation") \
1144         REQ_(OPTIONS,           "Open option menu"), \
1145         REQ_(TOGGLE_LINENO,     "Toggle line numbers"), \
1146         REQ_(TOGGLE_DATE,       "Toggle date display"), \
1147         REQ_(TOGGLE_DATE_SHORT, "Toggle short (date-only) dates"), \
1148         REQ_(TOGGLE_AUTHOR,     "Toggle author display"), \
1149         REQ_(TOGGLE_REV_GRAPH,  "Toggle revision graph visualization"), \
1150         REQ_(TOGGLE_REFS,       "Toggle reference display (tags/branches)"), \
1151         REQ_(TOGGLE_SORT_ORDER, "Toggle ascending/descending sort order"), \
1152         REQ_(TOGGLE_SORT_FIELD, "Toggle field to sort by"), \
1153         \
1154         REQ_GROUP("Misc") \
1155         REQ_(PROMPT,            "Bring up the prompt"), \
1156         REQ_(SCREEN_REDRAW,     "Redraw the screen"), \
1157         REQ_(SHOW_VERSION,      "Show version information"), \
1158         REQ_(STOP_LOADING,      "Stop all loading views"), \
1159         REQ_(EDIT,              "Open in editor"), \
1160         REQ_(NONE,              "Do nothing")
1163 /* User action requests. */
1164 enum request {
1165 #define REQ_GROUP(help)
1166 #define REQ_(req, help) REQ_##req
1168         /* Offset all requests to avoid conflicts with ncurses getch values. */
1169         REQ_OFFSET = KEY_MAX + 1,
1170         REQ_INFO
1172 #undef  REQ_GROUP
1173 #undef  REQ_
1174 };
1176 struct request_info {
1177         enum request request;
1178         const char *name;
1179         int namelen;
1180         const char *help;
1181 };
1183 static const struct request_info req_info[] = {
1184 #define REQ_GROUP(help) { 0, NULL, 0, (help) },
1185 #define REQ_(req, help) { REQ_##req, (#req), STRING_SIZE(#req), (help) }
1186         REQ_INFO
1187 #undef  REQ_GROUP
1188 #undef  REQ_
1189 };
1191 static enum request
1192 get_request(const char *name)
1194         int namelen = strlen(name);
1195         int i;
1197         for (i = 0; i < ARRAY_SIZE(req_info); i++)
1198                 if (enum_equals(req_info[i], name, namelen))
1199                         return req_info[i].request;
1201         return REQ_NONE;
1205 /*
1206  * Options
1207  */
1209 /* Option and state variables. */
1210 static enum date opt_date               = DATE_DEFAULT;
1211 static enum author opt_author           = AUTHOR_DEFAULT;
1212 static bool opt_line_number             = FALSE;
1213 static bool opt_line_graphics           = TRUE;
1214 static bool opt_rev_graph               = FALSE;
1215 static bool opt_show_refs               = TRUE;
1216 static int opt_num_interval             = 5;
1217 static double opt_hscroll               = 0.50;
1218 static double opt_scale_split_view      = 2.0 / 3.0;
1219 static int opt_tab_size                 = 8;
1220 static int opt_author_cols              = AUTHOR_COLS;
1221 static char opt_path[SIZEOF_STR]        = "";
1222 static char opt_file[SIZEOF_STR]        = "";
1223 static char opt_ref[SIZEOF_REF]         = "";
1224 static char opt_head[SIZEOF_REF]        = "";
1225 static char opt_remote[SIZEOF_REF]      = "";
1226 static char opt_encoding[20]            = "UTF-8";
1227 static iconv_t opt_iconv_in             = ICONV_NONE;
1228 static iconv_t opt_iconv_out            = ICONV_NONE;
1229 static char opt_search[SIZEOF_STR]      = "";
1230 static char opt_cdup[SIZEOF_STR]        = "";
1231 static char opt_prefix[SIZEOF_STR]      = "";
1232 static char opt_git_dir[SIZEOF_STR]     = "";
1233 static signed char opt_is_inside_work_tree      = -1; /* set to TRUE or FALSE */
1234 static char opt_editor[SIZEOF_STR]      = "";
1235 static FILE *opt_tty                    = NULL;
1237 #define is_initial_commit()     (!get_ref_head())
1238 #define is_head_commit(rev)     (!strcmp((rev), "HEAD") || (get_ref_head() && !strcmp(rev, get_ref_head()->id)))
1241 /*
1242  * Line-oriented content detection.
1243  */
1245 #define LINE_INFO \
1246 LINE(DIFF_HEADER,  "diff --git ",       COLOR_YELLOW,   COLOR_DEFAULT,  0), \
1247 LINE(DIFF_CHUNK,   "@@",                COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
1248 LINE(DIFF_ADD,     "+",                 COLOR_GREEN,    COLOR_DEFAULT,  0), \
1249 LINE(DIFF_DEL,     "-",                 COLOR_RED,      COLOR_DEFAULT,  0), \
1250 LINE(DIFF_INDEX,        "index ",         COLOR_BLUE,   COLOR_DEFAULT,  0), \
1251 LINE(DIFF_OLDMODE,      "old file mode ", COLOR_YELLOW, COLOR_DEFAULT,  0), \
1252 LINE(DIFF_NEWMODE,      "new file mode ", COLOR_YELLOW, COLOR_DEFAULT,  0), \
1253 LINE(DIFF_COPY_FROM,    "copy from",      COLOR_YELLOW, COLOR_DEFAULT,  0), \
1254 LINE(DIFF_COPY_TO,      "copy to",        COLOR_YELLOW, COLOR_DEFAULT,  0), \
1255 LINE(DIFF_RENAME_FROM,  "rename from",    COLOR_YELLOW, COLOR_DEFAULT,  0), \
1256 LINE(DIFF_RENAME_TO,    "rename to",      COLOR_YELLOW, COLOR_DEFAULT,  0), \
1257 LINE(DIFF_SIMILARITY,   "similarity ",    COLOR_YELLOW, COLOR_DEFAULT,  0), \
1258 LINE(DIFF_DISSIMILARITY,"dissimilarity ", COLOR_YELLOW, COLOR_DEFAULT,  0), \
1259 LINE(DIFF_TREE,         "diff-tree ",     COLOR_BLUE,   COLOR_DEFAULT,  0), \
1260 LINE(PP_AUTHOR,    "Author: ",          COLOR_CYAN,     COLOR_DEFAULT,  0), \
1261 LINE(PP_COMMIT,    "Commit: ",          COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
1262 LINE(PP_MERGE,     "Merge: ",           COLOR_BLUE,     COLOR_DEFAULT,  0), \
1263 LINE(PP_DATE,      "Date:   ",          COLOR_YELLOW,   COLOR_DEFAULT,  0), \
1264 LINE(PP_ADATE,     "AuthorDate: ",      COLOR_YELLOW,   COLOR_DEFAULT,  0), \
1265 LINE(PP_CDATE,     "CommitDate: ",      COLOR_YELLOW,   COLOR_DEFAULT,  0), \
1266 LINE(PP_REFS,      "Refs: ",            COLOR_RED,      COLOR_DEFAULT,  0), \
1267 LINE(COMMIT,       "commit ",           COLOR_GREEN,    COLOR_DEFAULT,  0), \
1268 LINE(PARENT,       "parent ",           COLOR_BLUE,     COLOR_DEFAULT,  0), \
1269 LINE(TREE,         "tree ",             COLOR_BLUE,     COLOR_DEFAULT,  0), \
1270 LINE(AUTHOR,       "author ",           COLOR_GREEN,    COLOR_DEFAULT,  0), \
1271 LINE(COMMITTER,    "committer ",        COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
1272 LINE(SIGNOFF,      "    Signed-off-by", COLOR_YELLOW,   COLOR_DEFAULT,  0), \
1273 LINE(ACKED,        "    Acked-by",      COLOR_YELLOW,   COLOR_DEFAULT,  0), \
1274 LINE(DEFAULT,      "",                  COLOR_DEFAULT,  COLOR_DEFAULT,  A_NORMAL), \
1275 LINE(CURSOR,       "",                  COLOR_WHITE,    COLOR_GREEN,    A_BOLD), \
1276 LINE(STATUS,       "",                  COLOR_GREEN,    COLOR_DEFAULT,  0), \
1277 LINE(DELIMITER,    "",                  COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
1278 LINE(DATE,         "",                  COLOR_BLUE,     COLOR_DEFAULT,  0), \
1279 LINE(MODE,         "",                  COLOR_CYAN,     COLOR_DEFAULT,  0), \
1280 LINE(LINE_NUMBER,  "",                  COLOR_CYAN,     COLOR_DEFAULT,  0), \
1281 LINE(TITLE_BLUR,   "",                  COLOR_WHITE,    COLOR_BLUE,     0), \
1282 LINE(TITLE_FOCUS,  "",                  COLOR_WHITE,    COLOR_BLUE,     A_BOLD), \
1283 LINE(MAIN_COMMIT,  "",                  COLOR_DEFAULT,  COLOR_DEFAULT,  0), \
1284 LINE(MAIN_TAG,     "",                  COLOR_MAGENTA,  COLOR_DEFAULT,  A_BOLD), \
1285 LINE(MAIN_LOCAL_TAG,"",                 COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
1286 LINE(MAIN_REMOTE,  "",                  COLOR_YELLOW,   COLOR_DEFAULT,  0), \
1287 LINE(MAIN_TRACKED, "",                  COLOR_YELLOW,   COLOR_DEFAULT,  A_BOLD), \
1288 LINE(MAIN_REF,     "",                  COLOR_CYAN,     COLOR_DEFAULT,  0), \
1289 LINE(MAIN_HEAD,    "",                  COLOR_CYAN,     COLOR_DEFAULT,  A_BOLD), \
1290 LINE(MAIN_REVGRAPH,"",                  COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
1291 LINE(TREE_HEAD,    "",                  COLOR_DEFAULT,  COLOR_DEFAULT,  A_BOLD), \
1292 LINE(TREE_DIR,     "",                  COLOR_YELLOW,   COLOR_DEFAULT,  A_NORMAL), \
1293 LINE(TREE_FILE,    "",                  COLOR_DEFAULT,  COLOR_DEFAULT,  A_NORMAL), \
1294 LINE(STAT_HEAD,    "",                  COLOR_YELLOW,   COLOR_DEFAULT,  0), \
1295 LINE(STAT_SECTION, "",                  COLOR_CYAN,     COLOR_DEFAULT,  0), \
1296 LINE(STAT_NONE,    "",                  COLOR_DEFAULT,  COLOR_DEFAULT,  0), \
1297 LINE(STAT_STAGED,  "",                  COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
1298 LINE(STAT_UNSTAGED,"",                  COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
1299 LINE(STAT_UNTRACKED,"",                 COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
1300 LINE(HELP_KEYMAP,  "",                  COLOR_CYAN,     COLOR_DEFAULT,  0), \
1301 LINE(HELP_GROUP,   "",                  COLOR_BLUE,     COLOR_DEFAULT,  0), \
1302 LINE(BLAME_ID,     "",                  COLOR_MAGENTA,  COLOR_DEFAULT,  0)
1304 enum line_type {
1305 #define LINE(type, line, fg, bg, attr) \
1306         LINE_##type
1307         LINE_INFO,
1308         LINE_NONE
1309 #undef  LINE
1310 };
1312 struct line_info {
1313         const char *name;       /* Option name. */
1314         int namelen;            /* Size of option name. */
1315         const char *line;       /* The start of line to match. */
1316         int linelen;            /* Size of string to match. */
1317         int fg, bg, attr;       /* Color and text attributes for the lines. */
1318 };
1320 static struct line_info line_info[] = {
1321 #define LINE(type, line, fg, bg, attr) \
1322         { #type, STRING_SIZE(#type), (line), STRING_SIZE(line), (fg), (bg), (attr) }
1323         LINE_INFO
1324 #undef  LINE
1325 };
1327 static enum line_type
1328 get_line_type(const char *line)
1330         int linelen = strlen(line);
1331         enum line_type type;
1333         for (type = 0; type < ARRAY_SIZE(line_info); type++)
1334                 /* Case insensitive search matches Signed-off-by lines better. */
1335                 if (linelen >= line_info[type].linelen &&
1336                     !strncasecmp(line_info[type].line, line, line_info[type].linelen))
1337                         return type;
1339         return LINE_DEFAULT;
1342 static inline int
1343 get_line_attr(enum line_type type)
1345         assert(type < ARRAY_SIZE(line_info));
1346         return COLOR_PAIR(type) | line_info[type].attr;
1349 static struct line_info *
1350 get_line_info(const char *name)
1352         size_t namelen = strlen(name);
1353         enum line_type type;
1355         for (type = 0; type < ARRAY_SIZE(line_info); type++)
1356                 if (enum_equals(line_info[type], name, namelen))
1357                         return &line_info[type];
1359         return NULL;
1362 static void
1363 init_colors(void)
1365         int default_bg = line_info[LINE_DEFAULT].bg;
1366         int default_fg = line_info[LINE_DEFAULT].fg;
1367         enum line_type type;
1369         start_color();
1371         if (assume_default_colors(default_fg, default_bg) == ERR) {
1372                 default_bg = COLOR_BLACK;
1373                 default_fg = COLOR_WHITE;
1374         }
1376         for (type = 0; type < ARRAY_SIZE(line_info); type++) {
1377                 struct line_info *info = &line_info[type];
1378                 int bg = info->bg == COLOR_DEFAULT ? default_bg : info->bg;
1379                 int fg = info->fg == COLOR_DEFAULT ? default_fg : info->fg;
1381                 init_pair(type, fg, bg);
1382         }
1385 struct line {
1386         enum line_type type;
1388         /* State flags */
1389         unsigned int selected:1;
1390         unsigned int dirty:1;
1391         unsigned int cleareol:1;
1392         unsigned int other:16;
1394         void *data;             /* User data */
1395 };
1398 /*
1399  * Keys
1400  */
1402 struct keybinding {
1403         int alias;
1404         enum request request;
1405 };
1407 static const struct keybinding default_keybindings[] = {
1408         /* View switching */
1409         { 'm',          REQ_VIEW_MAIN },
1410         { 'd',          REQ_VIEW_DIFF },
1411         { 'l',          REQ_VIEW_LOG },
1412         { 't',          REQ_VIEW_TREE },
1413         { 'f',          REQ_VIEW_BLOB },
1414         { 'B',          REQ_VIEW_BLAME },
1415         { 'H',          REQ_VIEW_BRANCH },
1416         { 'p',          REQ_VIEW_PAGER },
1417         { 'h',          REQ_VIEW_HELP },
1418         { 'S',          REQ_VIEW_STATUS },
1419         { 'c',          REQ_VIEW_STAGE },
1421         /* View manipulation */
1422         { 'q',          REQ_VIEW_CLOSE },
1423         { KEY_TAB,      REQ_VIEW_NEXT },
1424         { KEY_RETURN,   REQ_ENTER },
1425         { KEY_UP,       REQ_PREVIOUS },
1426         { KEY_DOWN,     REQ_NEXT },
1427         { 'R',          REQ_REFRESH },
1428         { KEY_F(5),     REQ_REFRESH },
1429         { 'O',          REQ_MAXIMIZE },
1431         /* Cursor navigation */
1432         { 'k',          REQ_MOVE_UP },
1433         { 'j',          REQ_MOVE_DOWN },
1434         { KEY_HOME,     REQ_MOVE_FIRST_LINE },
1435         { KEY_END,      REQ_MOVE_LAST_LINE },
1436         { KEY_NPAGE,    REQ_MOVE_PAGE_DOWN },
1437         { ' ',          REQ_MOVE_PAGE_DOWN },
1438         { KEY_PPAGE,    REQ_MOVE_PAGE_UP },
1439         { 'b',          REQ_MOVE_PAGE_UP },
1440         { '-',          REQ_MOVE_PAGE_UP },
1442         /* Scrolling */
1443         { KEY_LEFT,     REQ_SCROLL_LEFT },
1444         { KEY_RIGHT,    REQ_SCROLL_RIGHT },
1445         { KEY_IC,       REQ_SCROLL_LINE_UP },
1446         { KEY_DC,       REQ_SCROLL_LINE_DOWN },
1447         { 'w',          REQ_SCROLL_PAGE_UP },
1448         { 's',          REQ_SCROLL_PAGE_DOWN },
1450         /* Searching */
1451         { '/',          REQ_SEARCH },
1452         { '?',          REQ_SEARCH_BACK },
1453         { 'n',          REQ_FIND_NEXT },
1454         { 'N',          REQ_FIND_PREV },
1456         /* Misc */
1457         { 'Q',          REQ_QUIT },
1458         { 'z',          REQ_STOP_LOADING },
1459         { 'v',          REQ_SHOW_VERSION },
1460         { 'r',          REQ_SCREEN_REDRAW },
1461         { 'o',          REQ_OPTIONS },
1462         { '.',          REQ_TOGGLE_LINENO },
1463         { 'D',          REQ_TOGGLE_DATE },
1464         { 'A',          REQ_TOGGLE_AUTHOR },
1465         { 'g',          REQ_TOGGLE_REV_GRAPH },
1466         { 'F',          REQ_TOGGLE_REFS },
1467         { 'I',          REQ_TOGGLE_SORT_ORDER },
1468         { 'i',          REQ_TOGGLE_SORT_FIELD },
1469         { ':',          REQ_PROMPT },
1470         { 'u',          REQ_STATUS_UPDATE },
1471         { '!',          REQ_STATUS_REVERT },
1472         { 'M',          REQ_STATUS_MERGE },
1473         { '@',          REQ_STAGE_NEXT },
1474         { ',',          REQ_PARENT },
1475         { 'e',          REQ_EDIT },
1476 };
1478 #define KEYMAP_INFO \
1479         KEYMAP_(GENERIC), \
1480         KEYMAP_(MAIN), \
1481         KEYMAP_(DIFF), \
1482         KEYMAP_(LOG), \
1483         KEYMAP_(TREE), \
1484         KEYMAP_(BLOB), \
1485         KEYMAP_(BLAME), \
1486         KEYMAP_(BRANCH), \
1487         KEYMAP_(PAGER), \
1488         KEYMAP_(HELP), \
1489         KEYMAP_(STATUS), \
1490         KEYMAP_(STAGE)
1492 enum keymap {
1493 #define KEYMAP_(name) KEYMAP_##name
1494         KEYMAP_INFO
1495 #undef  KEYMAP_
1496 };
1498 static const struct enum_map keymap_table[] = {
1499 #define KEYMAP_(name) ENUM_MAP(#name, KEYMAP_##name)
1500         KEYMAP_INFO
1501 #undef  KEYMAP_
1502 };
1504 #define set_keymap(map, name) map_enum(map, keymap_table, name)
1506 struct keybinding_table {
1507         struct keybinding *data;
1508         size_t size;
1509 };
1511 static struct keybinding_table keybindings[ARRAY_SIZE(keymap_table)];
1513 static void
1514 add_keybinding(enum keymap keymap, enum request request, int key)
1516         struct keybinding_table *table = &keybindings[keymap];
1518         table->data = realloc(table->data, (table->size + 1) * sizeof(*table->data));
1519         if (!table->data)
1520                 die("Failed to allocate keybinding");
1521         table->data[table->size].alias = key;
1522         table->data[table->size++].request = request;
1525 /* Looks for a key binding first in the given map, then in the generic map, and
1526  * lastly in the default keybindings. */
1527 static enum request
1528 get_keybinding(enum keymap keymap, int key)
1530         size_t i;
1532         for (i = 0; i < keybindings[keymap].size; i++)
1533                 if (keybindings[keymap].data[i].alias == key)
1534                         return keybindings[keymap].data[i].request;
1536         for (i = 0; i < keybindings[KEYMAP_GENERIC].size; i++)
1537                 if (keybindings[KEYMAP_GENERIC].data[i].alias == key)
1538                         return keybindings[KEYMAP_GENERIC].data[i].request;
1540         for (i = 0; i < ARRAY_SIZE(default_keybindings); i++)
1541                 if (default_keybindings[i].alias == key)
1542                         return default_keybindings[i].request;
1544         return (enum request) key;
1548 struct key {
1549         const char *name;
1550         int value;
1551 };
1553 static const struct key key_table[] = {
1554         { "Enter",      KEY_RETURN },
1555         { "Space",      ' ' },
1556         { "Backspace",  KEY_BACKSPACE },
1557         { "Tab",        KEY_TAB },
1558         { "Escape",     KEY_ESC },
1559         { "Left",       KEY_LEFT },
1560         { "Right",      KEY_RIGHT },
1561         { "Up",         KEY_UP },
1562         { "Down",       KEY_DOWN },
1563         { "Insert",     KEY_IC },
1564         { "Delete",     KEY_DC },
1565         { "Hash",       '#' },
1566         { "Home",       KEY_HOME },
1567         { "End",        KEY_END },
1568         { "PageUp",     KEY_PPAGE },
1569         { "PageDown",   KEY_NPAGE },
1570         { "F1",         KEY_F(1) },
1571         { "F2",         KEY_F(2) },
1572         { "F3",         KEY_F(3) },
1573         { "F4",         KEY_F(4) },
1574         { "F5",         KEY_F(5) },
1575         { "F6",         KEY_F(6) },
1576         { "F7",         KEY_F(7) },
1577         { "F8",         KEY_F(8) },
1578         { "F9",         KEY_F(9) },
1579         { "F10",        KEY_F(10) },
1580         { "F11",        KEY_F(11) },
1581         { "F12",        KEY_F(12) },
1582 };
1584 static int
1585 get_key_value(const char *name)
1587         int i;
1589         for (i = 0; i < ARRAY_SIZE(key_table); i++)
1590                 if (!strcasecmp(key_table[i].name, name))
1591                         return key_table[i].value;
1593         if (strlen(name) == 1 && isprint(*name))
1594                 return (int) *name;
1596         return ERR;
1599 static const char *
1600 get_key_name(int key_value)
1602         static char key_char[] = "'X'";
1603         const char *seq = NULL;
1604         int key;
1606         for (key = 0; key < ARRAY_SIZE(key_table); key++)
1607                 if (key_table[key].value == key_value)
1608                         seq = key_table[key].name;
1610         if (seq == NULL &&
1611             key_value < 127 &&
1612             isprint(key_value)) {
1613                 key_char[1] = (char) key_value;
1614                 seq = key_char;
1615         }
1617         return seq ? seq : "(no key)";
1620 static bool
1621 append_key(char *buf, size_t *pos, const struct keybinding *keybinding)
1623         const char *sep = *pos > 0 ? ", " : "";
1624         const char *keyname = get_key_name(keybinding->alias);
1626         return string_nformat(buf, BUFSIZ, pos, "%s%s", sep, keyname);
1629 static bool
1630 append_keymap_request_keys(char *buf, size_t *pos, enum request request,
1631                            enum keymap keymap, bool all)
1633         int i;
1635         for (i = 0; i < keybindings[keymap].size; i++) {
1636                 if (keybindings[keymap].data[i].request == request) {
1637                         if (!append_key(buf, pos, &keybindings[keymap].data[i]))
1638                                 return FALSE;
1639                         if (!all)
1640                                 break;
1641                 }
1642         }
1644         return TRUE;
1647 #define get_key(keymap, request) get_keys(keymap, request, FALSE)
1649 static const char *
1650 get_keys(enum keymap keymap, enum request request, bool all)
1652         static char buf[BUFSIZ];
1653         size_t pos = 0;
1654         int i;
1656         buf[pos] = 0;
1658         if (!append_keymap_request_keys(buf, &pos, request, keymap, all))
1659                 return "Too many keybindings!";
1660         if (pos > 0 && !all)
1661                 return buf;
1663         if (keymap != KEYMAP_GENERIC) {
1664                 /* Only the generic keymap includes the default keybindings when
1665                  * listing all keys. */
1666                 if (all)
1667                         return buf;
1669                 if (!append_keymap_request_keys(buf, &pos, request, KEYMAP_GENERIC, all))
1670                         return "Too many keybindings!";
1671                 if (pos)
1672                         return buf;
1673         }
1675         for (i = 0; i < ARRAY_SIZE(default_keybindings); i++) {
1676                 if (default_keybindings[i].request == request) {
1677                         if (!append_key(buf, &pos, &default_keybindings[i]))
1678                                 return "Too many keybindings!";
1679                         if (!all)
1680                                 return buf;
1681                 }
1682         }
1684         return buf;
1687 struct run_request {
1688         enum keymap keymap;
1689         int key;
1690         const char *argv[SIZEOF_ARG];
1691 };
1693 static struct run_request *run_request;
1694 static size_t run_requests;
1696 DEFINE_ALLOCATOR(realloc_run_requests, struct run_request, 8)
1698 static enum request
1699 add_run_request(enum keymap keymap, int key, int argc, const char **argv)
1701         struct run_request *req;
1703         if (argc >= ARRAY_SIZE(req->argv) - 1)
1704                 return REQ_NONE;
1706         if (!realloc_run_requests(&run_request, run_requests, 1))
1707                 return REQ_NONE;
1709         req = &run_request[run_requests];
1710         req->keymap = keymap;
1711         req->key = key;
1712         req->argv[0] = NULL;
1714         if (!format_argv(req->argv, argv, FORMAT_NONE))
1715                 return REQ_NONE;
1717         return REQ_NONE + ++run_requests;
1720 static struct run_request *
1721 get_run_request(enum request request)
1723         if (request <= REQ_NONE)
1724                 return NULL;
1725         return &run_request[request - REQ_NONE - 1];
1728 static void
1729 add_builtin_run_requests(void)
1731         const char *cherry_pick[] = { "git", "cherry-pick", "%(commit)", NULL };
1732         const char *checkout[] = { "git", "checkout", "%(branch)", NULL };
1733         const char *commit[] = { "git", "commit", NULL };
1734         const char *gc[] = { "git", "gc", NULL };
1735         struct {
1736                 enum keymap keymap;
1737                 int key;
1738                 int argc;
1739                 const char **argv;
1740         } reqs[] = {
1741                 { KEYMAP_MAIN,    'C', ARRAY_SIZE(cherry_pick) - 1, cherry_pick },
1742                 { KEYMAP_STATUS,  'C', ARRAY_SIZE(commit) - 1, commit },
1743                 { KEYMAP_BRANCH,  'C', ARRAY_SIZE(checkout) - 1, checkout },
1744                 { KEYMAP_GENERIC, 'G', ARRAY_SIZE(gc) - 1, gc },
1745         };
1746         int i;
1748         for (i = 0; i < ARRAY_SIZE(reqs); i++) {
1749                 enum request req;
1751                 req = add_run_request(reqs[i].keymap, reqs[i].key, reqs[i].argc, reqs[i].argv);
1752                 if (req != REQ_NONE)
1753                         add_keybinding(reqs[i].keymap, req, reqs[i].key);
1754         }
1757 /*
1758  * User config file handling.
1759  */
1761 static int   config_lineno;
1762 static bool  config_errors;
1763 static const char *config_msg;
1765 static const struct enum_map color_map[] = {
1766 #define COLOR_MAP(name) ENUM_MAP(#name, COLOR_##name)
1767         COLOR_MAP(DEFAULT),
1768         COLOR_MAP(BLACK),
1769         COLOR_MAP(BLUE),
1770         COLOR_MAP(CYAN),
1771         COLOR_MAP(GREEN),
1772         COLOR_MAP(MAGENTA),
1773         COLOR_MAP(RED),
1774         COLOR_MAP(WHITE),
1775         COLOR_MAP(YELLOW),
1776 };
1778 static const struct enum_map attr_map[] = {
1779 #define ATTR_MAP(name) ENUM_MAP(#name, A_##name)
1780         ATTR_MAP(NORMAL),
1781         ATTR_MAP(BLINK),
1782         ATTR_MAP(BOLD),
1783         ATTR_MAP(DIM),
1784         ATTR_MAP(REVERSE),
1785         ATTR_MAP(STANDOUT),
1786         ATTR_MAP(UNDERLINE),
1787 };
1789 #define set_attribute(attr, name)       map_enum(attr, attr_map, name)
1791 static int parse_step(double *opt, const char *arg)
1793         *opt = atoi(arg);
1794         if (!strchr(arg, '%'))
1795                 return OK;
1797         /* "Shift down" so 100% and 1 does not conflict. */
1798         *opt = (*opt - 1) / 100;
1799         if (*opt >= 1.0) {
1800                 *opt = 0.99;
1801                 config_msg = "Step value larger than 100%";
1802                 return ERR;
1803         }
1804         if (*opt < 0.0) {
1805                 *opt = 1;
1806                 config_msg = "Invalid step value";
1807                 return ERR;
1808         }
1809         return OK;
1812 static int
1813 parse_int(int *opt, const char *arg, int min, int max)
1815         int value = atoi(arg);
1817         if (min <= value && value <= max) {
1818                 *opt = value;
1819                 return OK;
1820         }
1822         config_msg = "Integer value out of bound";
1823         return ERR;
1826 static bool
1827 set_color(int *color, const char *name)
1829         if (map_enum(color, color_map, name))
1830                 return TRUE;
1831         if (!prefixcmp(name, "color"))
1832                 return parse_int(color, name + 5, 0, 255) == OK;
1833         return FALSE;
1836 /* Wants: object fgcolor bgcolor [attribute] */
1837 static int
1838 option_color_command(int argc, const char *argv[])
1840         struct line_info *info;
1842         if (argc < 3) {
1843                 config_msg = "Wrong number of arguments given to color command";
1844                 return ERR;
1845         }
1847         info = get_line_info(argv[0]);
1848         if (!info) {
1849                 static const struct enum_map obsolete[] = {
1850                         ENUM_MAP("main-delim",  LINE_DELIMITER),
1851                         ENUM_MAP("main-date",   LINE_DATE),
1852                         ENUM_MAP("main-author", LINE_AUTHOR),
1853                 };
1854                 int index;
1856                 if (!map_enum(&index, obsolete, argv[0])) {
1857                         config_msg = "Unknown color name";
1858                         return ERR;
1859                 }
1860                 info = &line_info[index];
1861         }
1863         if (!set_color(&info->fg, argv[1]) ||
1864             !set_color(&info->bg, argv[2])) {
1865                 config_msg = "Unknown color";
1866                 return ERR;
1867         }
1869         info->attr = 0;
1870         while (argc-- > 3) {
1871                 int attr;
1873                 if (!set_attribute(&attr, argv[argc])) {
1874                         config_msg = "Unknown attribute";
1875                         return ERR;
1876                 }
1877                 info->attr |= attr;
1878         }
1880         return OK;
1883 static int parse_bool(bool *opt, const char *arg)
1885         *opt = (!strcmp(arg, "1") || !strcmp(arg, "true") || !strcmp(arg, "yes"))
1886                 ? TRUE : FALSE;
1887         return OK;
1890 static int parse_enum_do(unsigned int *opt, const char *arg,
1891                          const struct enum_map *map, size_t map_size)
1893         bool is_true;
1895         assert(map_size > 1);
1897         if (map_enum_do(map, map_size, (int *) opt, arg))
1898                 return OK;
1900         if (parse_bool(&is_true, arg) != OK)
1901                 return ERR;
1903         *opt = is_true ? map[1].value : map[0].value;
1904         return OK;
1907 #define parse_enum(opt, arg, map) \
1908         parse_enum_do(opt, arg, map, ARRAY_SIZE(map))
1910 static int
1911 parse_string(char *opt, const char *arg, size_t optsize)
1913         int arglen = strlen(arg);
1915         switch (arg[0]) {
1916         case '\"':
1917         case '\'':
1918                 if (arglen == 1 || arg[arglen - 1] != arg[0]) {
1919                         config_msg = "Unmatched quotation";
1920                         return ERR;
1921                 }
1922                 arg += 1; arglen -= 2;
1923         default:
1924                 string_ncopy_do(opt, optsize, arg, arglen);
1925                 return OK;
1926         }
1929 /* Wants: name = value */
1930 static int
1931 option_set_command(int argc, const char *argv[])
1933         if (argc != 3) {
1934                 config_msg = "Wrong number of arguments given to set command";
1935                 return ERR;
1936         }
1938         if (strcmp(argv[1], "=")) {
1939                 config_msg = "No value assigned";
1940                 return ERR;
1941         }
1943         if (!strcmp(argv[0], "show-author"))
1944                 return parse_enum(&opt_author, argv[2], author_map);
1946         if (!strcmp(argv[0], "show-date"))
1947                 return parse_enum(&opt_date, argv[2], date_map);
1949         if (!strcmp(argv[0], "show-rev-graph"))
1950                 return parse_bool(&opt_rev_graph, argv[2]);
1952         if (!strcmp(argv[0], "show-refs"))
1953                 return parse_bool(&opt_show_refs, argv[2]);
1955         if (!strcmp(argv[0], "show-line-numbers"))
1956                 return parse_bool(&opt_line_number, argv[2]);
1958         if (!strcmp(argv[0], "line-graphics"))
1959                 return parse_bool(&opt_line_graphics, argv[2]);
1961         if (!strcmp(argv[0], "line-number-interval"))
1962                 return parse_int(&opt_num_interval, argv[2], 1, 1024);
1964         if (!strcmp(argv[0], "author-width"))
1965                 return parse_int(&opt_author_cols, argv[2], 0, 1024);
1967         if (!strcmp(argv[0], "horizontal-scroll"))
1968                 return parse_step(&opt_hscroll, argv[2]);
1970         if (!strcmp(argv[0], "split-view-height"))
1971                 return parse_step(&opt_scale_split_view, argv[2]);
1973         if (!strcmp(argv[0], "tab-size"))
1974                 return parse_int(&opt_tab_size, argv[2], 1, 1024);
1976         if (!strcmp(argv[0], "commit-encoding"))
1977                 return parse_string(opt_encoding, argv[2], sizeof(opt_encoding));
1979         config_msg = "Unknown variable name";
1980         return ERR;
1983 /* Wants: mode request key */
1984 static int
1985 option_bind_command(int argc, const char *argv[])
1987         enum request request;
1988         int keymap = -1;
1989         int key;
1991         if (argc < 3) {
1992                 config_msg = "Wrong number of arguments given to bind command";
1993                 return ERR;
1994         }
1996         if (set_keymap(&keymap, argv[0]) == ERR) {
1997                 config_msg = "Unknown key map";
1998                 return ERR;
1999         }
2001         key = get_key_value(argv[1]);
2002         if (key == ERR) {
2003                 config_msg = "Unknown key";
2004                 return ERR;
2005         }
2007         request = get_request(argv[2]);
2008         if (request == REQ_NONE) {
2009                 static const struct enum_map obsolete[] = {
2010                         ENUM_MAP("cherry-pick",         REQ_NONE),
2011                         ENUM_MAP("screen-resize",       REQ_NONE),
2012                         ENUM_MAP("tree-parent",         REQ_PARENT),
2013                 };
2014                 int alias;
2016                 if (map_enum(&alias, obsolete, argv[2])) {
2017                         if (alias != REQ_NONE)
2018                                 add_keybinding(keymap, alias, key);
2019                         config_msg = "Obsolete request name";
2020                         return ERR;
2021                 }
2022         }
2023         if (request == REQ_NONE && *argv[2]++ == '!')
2024                 request = add_run_request(keymap, key, argc - 2, argv + 2);
2025         if (request == REQ_NONE) {
2026                 config_msg = "Unknown request name";
2027                 return ERR;
2028         }
2030         add_keybinding(keymap, request, key);
2032         return OK;
2035 static int
2036 set_option(const char *opt, char *value)
2038         const char *argv[SIZEOF_ARG];
2039         int argc = 0;
2041         if (!argv_from_string(argv, &argc, value)) {
2042                 config_msg = "Too many option arguments";
2043                 return ERR;
2044         }
2046         if (!strcmp(opt, "color"))
2047                 return option_color_command(argc, argv);
2049         if (!strcmp(opt, "set"))
2050                 return option_set_command(argc, argv);
2052         if (!strcmp(opt, "bind"))
2053                 return option_bind_command(argc, argv);
2055         config_msg = "Unknown option command";
2056         return ERR;
2059 static int
2060 read_option(char *opt, size_t optlen, char *value, size_t valuelen)
2062         int status = OK;
2064         config_lineno++;
2065         config_msg = "Internal error";
2067         /* Check for comment markers, since read_properties() will
2068          * only ensure opt and value are split at first " \t". */
2069         optlen = strcspn(opt, "#");
2070         if (optlen == 0)
2071                 return OK;
2073         if (opt[optlen] != 0) {
2074                 config_msg = "No option value";
2075                 status = ERR;
2077         }  else {
2078                 /* Look for comment endings in the value. */
2079                 size_t len = strcspn(value, "#");
2081                 if (len < valuelen) {
2082                         valuelen = len;
2083                         value[valuelen] = 0;
2084                 }
2086                 status = set_option(opt, value);
2087         }
2089         if (status == ERR) {
2090                 warn("Error on line %d, near '%.*s': %s",
2091                      config_lineno, (int) optlen, opt, config_msg);
2092                 config_errors = TRUE;
2093         }
2095         /* Always keep going if errors are encountered. */
2096         return OK;
2099 static void
2100 load_option_file(const char *path)
2102         struct io io = {};
2104         /* It's OK that the file doesn't exist. */
2105         if (!io_open(&io, "%s", path))
2106                 return;
2108         config_lineno = 0;
2109         config_errors = FALSE;
2111         if (io_load(&io, " \t", read_option) == ERR ||
2112             config_errors == TRUE)
2113                 warn("Errors while loading %s.", path);
2116 static int
2117 load_options(void)
2119         const char *home = getenv("HOME");
2120         const char *tigrc_user = getenv("TIGRC_USER");
2121         const char *tigrc_system = getenv("TIGRC_SYSTEM");
2122         char buf[SIZEOF_STR];
2124         add_builtin_run_requests();
2126         if (!tigrc_system)
2127                 tigrc_system = SYSCONFDIR "/tigrc";
2128         load_option_file(tigrc_system);
2130         if (!tigrc_user) {
2131                 if (!home || !string_format(buf, "%s/.tigrc", home))
2132                         return ERR;
2133                 tigrc_user = buf;
2134         }
2135         load_option_file(tigrc_user);
2137         return OK;
2141 /*
2142  * The viewer
2143  */
2145 struct view;
2146 struct view_ops;
2148 /* The display array of active views and the index of the current view. */
2149 static struct view *display[2];
2150 static unsigned int current_view;
2152 #define foreach_displayed_view(view, i) \
2153         for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
2155 #define displayed_views()       (display[1] != NULL ? 2 : 1)
2157 /* Current head and commit ID */
2158 static char ref_blob[SIZEOF_REF]        = "";
2159 static char ref_commit[SIZEOF_REF]      = "HEAD";
2160 static char ref_head[SIZEOF_REF]        = "HEAD";
2161 static char ref_branch[SIZEOF_REF]      = "";
2163 struct view {
2164         const char *name;       /* View name */
2165         const char *cmd_env;    /* Command line set via environment */
2166         const char *id;         /* Points to either of ref_{head,commit,blob} */
2168         struct view_ops *ops;   /* View operations */
2170         enum keymap keymap;     /* What keymap does this view have */
2171         bool git_dir;           /* Whether the view requires a git directory. */
2172         bool refresh;           /* Whether the view supports refreshing. */
2174         char ref[SIZEOF_REF];   /* Hovered commit reference */
2175         char vid[SIZEOF_REF];   /* View ID. Set to id member when updating. */
2177         int height, width;      /* The width and height of the main window */
2178         WINDOW *win;            /* The main window */
2179         WINDOW *title;          /* The title window living below the main window */
2181         /* Navigation */
2182         unsigned long offset;   /* Offset of the window top */
2183         unsigned long yoffset;  /* Offset from the window side. */
2184         unsigned long lineno;   /* Current line number */
2185         unsigned long p_offset; /* Previous offset of the window top */
2186         unsigned long p_yoffset;/* Previous offset from the window side */
2187         unsigned long p_lineno; /* Previous current line number */
2188         bool p_restore;         /* Should the previous position be restored. */
2190         /* Searching */
2191         char grep[SIZEOF_STR];  /* Search string */
2192         regex_t *regex;         /* Pre-compiled regexp */
2194         /* If non-NULL, points to the view that opened this view. If this view
2195          * is closed tig will switch back to the parent view. */
2196         struct view *parent;
2198         /* Buffering */
2199         size_t lines;           /* Total number of lines */
2200         struct line *line;      /* Line index */
2201         unsigned int digits;    /* Number of digits in the lines member. */
2203         /* Drawing */
2204         struct line *curline;   /* Line currently being drawn. */
2205         enum line_type curtype; /* Attribute currently used for drawing. */
2206         unsigned long col;      /* Column when drawing. */
2207         bool has_scrolled;      /* View was scrolled. */
2209         /* Loading */
2210         struct io io;
2211         struct io *pipe;
2212         time_t start_time;
2213         time_t update_secs;
2214 };
2216 struct view_ops {
2217         /* What type of content being displayed. Used in the title bar. */
2218         const char *type;
2219         /* Default command arguments. */
2220         const char **argv;
2221         /* Open and reads in all view content. */
2222         bool (*open)(struct view *view);
2223         /* Read one line; updates view->line. */
2224         bool (*read)(struct view *view, char *data);
2225         /* Draw one line; @lineno must be < view->height. */
2226         bool (*draw)(struct view *view, struct line *line, unsigned int lineno);
2227         /* Depending on view handle a special requests. */
2228         enum request (*request)(struct view *view, enum request request, struct line *line);
2229         /* Search for regexp in a line. */
2230         bool (*grep)(struct view *view, struct line *line);
2231         /* Select line */
2232         void (*select)(struct view *view, struct line *line);
2233         /* Prepare view for loading */
2234         bool (*prepare)(struct view *view);
2235 };
2237 static struct view_ops blame_ops;
2238 static struct view_ops blob_ops;
2239 static struct view_ops diff_ops;
2240 static struct view_ops help_ops;
2241 static struct view_ops log_ops;
2242 static struct view_ops main_ops;
2243 static struct view_ops pager_ops;
2244 static struct view_ops stage_ops;
2245 static struct view_ops status_ops;
2246 static struct view_ops tree_ops;
2247 static struct view_ops branch_ops;
2249 #define VIEW_STR(name, env, ref, ops, map, git, refresh) \
2250         { name, #env, ref, ops, map, git, refresh }
2252 #define VIEW_(id, name, ops, git, refresh, ref) \
2253         VIEW_STR(name, TIG_##id##_CMD, ref, ops, KEYMAP_##id, git, refresh)
2255 static struct view views[] = {
2256         VIEW_(MAIN,   "main",   &main_ops,   TRUE,  TRUE,  ref_head),
2257         VIEW_(DIFF,   "diff",   &diff_ops,   TRUE,  FALSE, ref_commit),
2258         VIEW_(LOG,    "log",    &log_ops,    TRUE,  TRUE,  ref_head),
2259         VIEW_(TREE,   "tree",   &tree_ops,   TRUE,  FALSE, ref_commit),
2260         VIEW_(BLOB,   "blob",   &blob_ops,   TRUE,  FALSE, ref_blob),
2261         VIEW_(BLAME,  "blame",  &blame_ops,  TRUE,  FALSE, ref_commit),
2262         VIEW_(BRANCH, "branch", &branch_ops, TRUE,  TRUE,  ref_head),
2263         VIEW_(HELP,   "help",   &help_ops,   FALSE, FALSE, ""),
2264         VIEW_(PAGER,  "pager",  &pager_ops,  FALSE, FALSE, "stdin"),
2265         VIEW_(STATUS, "status", &status_ops, TRUE,  TRUE,  ""),
2266         VIEW_(STAGE,  "stage",  &stage_ops,  TRUE,  TRUE,  ""),
2267 };
2269 #define VIEW(req)       (&views[(req) - REQ_OFFSET - 1])
2270 #define VIEW_REQ(view)  ((view) - views + REQ_OFFSET + 1)
2272 #define foreach_view(view, i) \
2273         for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
2275 #define view_is_displayed(view) \
2276         (view == display[0] || view == display[1])
2279 static inline void
2280 set_view_attr(struct view *view, enum line_type type)
2282         if (!view->curline->selected && view->curtype != type) {
2283                 (void) wattrset(view->win, get_line_attr(type));
2284                 wchgat(view->win, -1, 0, type, NULL);
2285                 view->curtype = type;
2286         }
2289 static int
2290 draw_chars(struct view *view, enum line_type type, const char *string,
2291            int max_len, bool use_tilde)
2293         static char out_buffer[BUFSIZ * 2];
2294         int len = 0;
2295         int col = 0;
2296         int trimmed = FALSE;
2297         size_t skip = view->yoffset > view->col ? view->yoffset - view->col : 0;
2299         if (max_len <= 0)
2300                 return 0;
2302         len = utf8_length(&string, skip, &col, max_len, &trimmed, use_tilde, opt_tab_size);
2304         set_view_attr(view, type);
2305         if (len > 0) {
2306                 if (opt_iconv_out != ICONV_NONE) {
2307                         ICONV_CONST char *inbuf = (ICONV_CONST char *) string;
2308                         size_t inlen = len + 1;
2310                         char *outbuf = out_buffer;
2311                         size_t outlen = sizeof(out_buffer);
2313                         size_t ret;
2315                         ret = iconv(opt_iconv_out, &inbuf, &inlen, &outbuf, &outlen);
2316                         if (ret != (size_t) -1) {
2317                                 string = out_buffer;
2318                                 len = sizeof(out_buffer) - outlen;
2319                         }
2320                 }
2322                 waddnstr(view->win, string, len);
2323         }
2324         if (trimmed && use_tilde) {
2325                 set_view_attr(view, LINE_DELIMITER);
2326                 waddch(view->win, '~');
2327                 col++;
2328         }
2330         return col;
2333 static int
2334 draw_space(struct view *view, enum line_type type, int max, int spaces)
2336         static char space[] = "                    ";
2337         int col = 0;
2339         spaces = MIN(max, spaces);
2341         while (spaces > 0) {
2342                 int len = MIN(spaces, sizeof(space) - 1);
2344                 col += draw_chars(view, type, space, len, FALSE);
2345                 spaces -= len;
2346         }
2348         return col;
2351 static bool
2352 draw_text(struct view *view, enum line_type type, const char *string, bool trim)
2354         view->col += draw_chars(view, type, string, view->width + view->yoffset - view->col, trim);
2355         return view->width + view->yoffset <= view->col;
2358 static bool
2359 draw_graphic(struct view *view, enum line_type type, chtype graphic[], size_t size)
2361         size_t skip = view->yoffset > view->col ? view->yoffset - view->col : 0;
2362         int max = view->width + view->yoffset - view->col;
2363         int i;
2365         if (max < size)
2366                 size = max;
2368         set_view_attr(view, type);
2369         /* Using waddch() instead of waddnstr() ensures that
2370          * they'll be rendered correctly for the cursor line. */
2371         for (i = skip; i < size; i++)
2372                 waddch(view->win, graphic[i]);
2374         view->col += size;
2375         if (size < max && skip <= size)
2376                 waddch(view->win, ' ');
2377         view->col++;
2379         return view->width + view->yoffset <= view->col;
2382 static bool
2383 draw_field(struct view *view, enum line_type type, const char *text, int len, bool trim)
2385         int max = MIN(view->width + view->yoffset - view->col, len);
2386         int col;
2388         if (text)
2389                 col = draw_chars(view, type, text, max - 1, trim);
2390         else
2391                 col = draw_space(view, type, max - 1, max - 1);
2393         view->col += col;
2394         view->col += draw_space(view, LINE_DEFAULT, max - col, max - col);
2395         return view->width + view->yoffset <= view->col;
2398 static bool
2399 draw_date(struct view *view, struct time *time)
2401         const char *date = mkdate(time, opt_date);
2402         int cols = opt_date == DATE_SHORT ? DATE_SHORT_COLS : DATE_COLS;
2404         return draw_field(view, LINE_DATE, date, cols, FALSE);
2407 static bool
2408 draw_author(struct view *view, const char *author)
2410         bool trim = opt_author_cols == 0 || opt_author_cols > 5;
2411         bool abbreviate = opt_author == AUTHOR_ABBREVIATED || !trim;
2413         if (abbreviate && author)
2414                 author = get_author_initials(author);
2416         return draw_field(view, LINE_AUTHOR, author, opt_author_cols, trim);
2419 static bool
2420 draw_mode(struct view *view, mode_t mode)
2422         const char *str;
2424         if (S_ISDIR(mode))
2425                 str = "drwxr-xr-x";
2426         else if (S_ISLNK(mode))
2427                 str = "lrwxrwxrwx";
2428         else if (S_ISGITLINK(mode))
2429                 str = "m---------";
2430         else if (S_ISREG(mode) && mode & S_IXUSR)
2431                 str = "-rwxr-xr-x";
2432         else if (S_ISREG(mode))
2433                 str = "-rw-r--r--";
2434         else
2435                 str = "----------";
2437         return draw_field(view, LINE_MODE, str, STRING_SIZE("-rw-r--r-- "), FALSE);
2440 static bool
2441 draw_lineno(struct view *view, unsigned int lineno)
2443         char number[10];
2444         int digits3 = view->digits < 3 ? 3 : view->digits;
2445         int max = MIN(view->width + view->yoffset - view->col, digits3);
2446         char *text = NULL;
2447         chtype separator = opt_line_graphics ? ACS_VLINE : '|';
2449         lineno += view->offset + 1;
2450         if (lineno == 1 || (lineno % opt_num_interval) == 0) {
2451                 static char fmt[] = "%1ld";
2453                 fmt[1] = '0' + (view->digits <= 9 ? digits3 : 1);
2454                 if (string_format(number, fmt, lineno))
2455                         text = number;
2456         }
2457         if (text)
2458                 view->col += draw_chars(view, LINE_LINE_NUMBER, text, max, TRUE);
2459         else
2460                 view->col += draw_space(view, LINE_LINE_NUMBER, max, digits3);
2461         return draw_graphic(view, LINE_DEFAULT, &separator, 1);
2464 static bool
2465 draw_view_line(struct view *view, unsigned int lineno)
2467         struct line *line;
2468         bool selected = (view->offset + lineno == view->lineno);
2470         assert(view_is_displayed(view));
2472         if (view->offset + lineno >= view->lines)
2473                 return FALSE;
2475         line = &view->line[view->offset + lineno];
2477         wmove(view->win, lineno, 0);
2478         if (line->cleareol)
2479                 wclrtoeol(view->win);
2480         view->col = 0;
2481         view->curline = line;
2482         view->curtype = LINE_NONE;
2483         line->selected = FALSE;
2484         line->dirty = line->cleareol = 0;
2486         if (selected) {
2487                 set_view_attr(view, LINE_CURSOR);
2488                 line->selected = TRUE;
2489                 view->ops->select(view, line);
2490         }
2492         return view->ops->draw(view, line, lineno);
2495 static void
2496 redraw_view_dirty(struct view *view)
2498         bool dirty = FALSE;
2499         int lineno;
2501         for (lineno = 0; lineno < view->height; lineno++) {
2502                 if (view->offset + lineno >= view->lines)
2503                         break;
2504                 if (!view->line[view->offset + lineno].dirty)
2505                         continue;
2506                 dirty = TRUE;
2507                 if (!draw_view_line(view, lineno))
2508                         break;
2509         }
2511         if (!dirty)
2512                 return;
2513         wnoutrefresh(view->win);
2516 static void
2517 redraw_view_from(struct view *view, int lineno)
2519         assert(0 <= lineno && lineno < view->height);
2521         for (; lineno < view->height; lineno++) {
2522                 if (!draw_view_line(view, lineno))
2523                         break;
2524         }
2526         wnoutrefresh(view->win);
2529 static void
2530 redraw_view(struct view *view)
2532         werase(view->win);
2533         redraw_view_from(view, 0);
2537 static void
2538 update_view_title(struct view *view)
2540         char buf[SIZEOF_STR];
2541         char state[SIZEOF_STR];
2542         size_t bufpos = 0, statelen = 0;
2544         assert(view_is_displayed(view));
2546         if (view != VIEW(REQ_VIEW_STATUS) && view->lines) {
2547                 unsigned int view_lines = view->offset + view->height;
2548                 unsigned int lines = view->lines
2549                                    ? MIN(view_lines, view->lines) * 100 / view->lines
2550                                    : 0;
2552                 string_format_from(state, &statelen, " - %s %d of %d (%d%%)",
2553                                    view->ops->type,
2554                                    view->lineno + 1,
2555                                    view->lines,
2556                                    lines);
2558         }
2560         if (view->pipe) {
2561                 time_t secs = time(NULL) - view->start_time;
2563                 /* Three git seconds are a long time ... */
2564                 if (secs > 2)
2565                         string_format_from(state, &statelen, " loading %lds", secs);
2566         }
2568         string_format_from(buf, &bufpos, "[%s]", view->name);
2569         if (*view->ref && bufpos < view->width) {
2570                 size_t refsize = strlen(view->ref);
2571                 size_t minsize = bufpos + 1 + /* abbrev= */ 7 + 1 + statelen;
2573                 if (minsize < view->width)
2574                         refsize = view->width - minsize + 7;
2575                 string_format_from(buf, &bufpos, " %.*s", (int) refsize, view->ref);
2576         }
2578         if (statelen && bufpos < view->width) {
2579                 string_format_from(buf, &bufpos, "%s", state);
2580         }
2582         if (view == display[current_view])
2583                 wbkgdset(view->title, get_line_attr(LINE_TITLE_FOCUS));
2584         else
2585                 wbkgdset(view->title, get_line_attr(LINE_TITLE_BLUR));
2587         mvwaddnstr(view->title, 0, 0, buf, bufpos);
2588         wclrtoeol(view->title);
2589         wnoutrefresh(view->title);
2592 static int
2593 apply_step(double step, int value)
2595         if (step >= 1)
2596                 return (int) step;
2597         value *= step + 0.01;
2598         return value ? value : 1;
2601 static void
2602 resize_display(void)
2604         int offset, i;
2605         struct view *base = display[0];
2606         struct view *view = display[1] ? display[1] : display[0];
2608         /* Setup window dimensions */
2610         getmaxyx(stdscr, base->height, base->width);
2612         /* Make room for the status window. */
2613         base->height -= 1;
2615         if (view != base) {
2616                 /* Horizontal split. */
2617                 view->width   = base->width;
2618                 view->height  = apply_step(opt_scale_split_view, base->height);
2619                 view->height  = MAX(view->height, MIN_VIEW_HEIGHT);
2620                 view->height  = MIN(view->height, base->height - MIN_VIEW_HEIGHT);
2621                 base->height -= view->height;
2623                 /* Make room for the title bar. */
2624                 view->height -= 1;
2625         }
2627         /* Make room for the title bar. */
2628         base->height -= 1;
2630         offset = 0;
2632         foreach_displayed_view (view, i) {
2633                 if (!view->win) {
2634                         view->win = newwin(view->height, 0, offset, 0);
2635                         if (!view->win)
2636                                 die("Failed to create %s view", view->name);
2638                         scrollok(view->win, FALSE);
2640                         view->title = newwin(1, 0, offset + view->height, 0);
2641                         if (!view->title)
2642                                 die("Failed to create title window");
2644                 } else {
2645                         wresize(view->win, view->height, view->width);
2646                         mvwin(view->win,   offset, 0);
2647                         mvwin(view->title, offset + view->height, 0);
2648                 }
2650                 offset += view->height + 1;
2651         }
2654 static void
2655 redraw_display(bool clear)
2657         struct view *view;
2658         int i;
2660         foreach_displayed_view (view, i) {
2661                 if (clear)
2662                         wclear(view->win);
2663                 redraw_view(view);
2664                 update_view_title(view);
2665         }
2668 static void
2669 toggle_enum_option_do(unsigned int *opt, const char *help,
2670                       const struct enum_map *map, size_t size)
2672         *opt = (*opt + 1) % size;
2673         redraw_display(FALSE);
2674         report("Displaying %s %s", enum_name(map[*opt]), help);
2677 #define toggle_enum_option(opt, help, map) \
2678         toggle_enum_option_do(opt, help, map, ARRAY_SIZE(map))
2680 #define toggle_date() toggle_enum_option(&opt_date, "dates", date_map)
2681 #define toggle_author() toggle_enum_option(&opt_author, "author names", author_map)
2683 static void
2684 toggle_view_option(bool *option, const char *help)
2686         *option = !*option;
2687         redraw_display(FALSE);
2688         report("%sabling %s", *option ? "En" : "Dis", help);
2691 static void
2692 open_option_menu(void)
2694         const struct menu_item menu[] = {
2695                 { '.', "line numbers", &opt_line_number },
2696                 { 'D', "date display", &opt_date },
2697                 { 'A', "author display", &opt_author },
2698                 { 'g', "revision graph display", &opt_rev_graph },
2699                 { 'F', "reference display", &opt_show_refs },
2700                 { 0 }
2701         };
2702         int selected = 0;
2704         if (prompt_menu("Toggle option", menu, &selected)) {
2705                 if (menu[selected].data == &opt_date)
2706                         toggle_date();
2707                 else if (menu[selected].data == &opt_author)
2708                         toggle_author();
2709                 else
2710                         toggle_view_option(menu[selected].data, menu[selected].text);
2711         }
2714 static void
2715 maximize_view(struct view *view)
2717         memset(display, 0, sizeof(display));
2718         current_view = 0;
2719         display[current_view] = view;
2720         resize_display();
2721         redraw_display(FALSE);
2722         report("");
2726 /*
2727  * Navigation
2728  */
2730 static bool
2731 goto_view_line(struct view *view, unsigned long offset, unsigned long lineno)
2733         if (lineno >= view->lines)
2734                 lineno = view->lines > 0 ? view->lines - 1 : 0;
2736         if (offset > lineno || offset + view->height <= lineno) {
2737                 unsigned long half = view->height / 2;
2739                 if (lineno > half)
2740                         offset = lineno - half;
2741                 else
2742                         offset = 0;
2743         }
2745         if (offset != view->offset || lineno != view->lineno) {
2746                 view->offset = offset;
2747                 view->lineno = lineno;
2748                 return TRUE;
2749         }
2751         return FALSE;
2754 /* Scrolling backend */
2755 static void
2756 do_scroll_view(struct view *view, int lines)
2758         bool redraw_current_line = FALSE;
2760         /* The rendering expects the new offset. */
2761         view->offset += lines;
2763         assert(0 <= view->offset && view->offset < view->lines);
2764         assert(lines);
2766         /* Move current line into the view. */
2767         if (view->lineno < view->offset) {
2768                 view->lineno = view->offset;
2769                 redraw_current_line = TRUE;
2770         } else if (view->lineno >= view->offset + view->height) {
2771                 view->lineno = view->offset + view->height - 1;
2772                 redraw_current_line = TRUE;
2773         }
2775         assert(view->offset <= view->lineno && view->lineno < view->lines);
2777         /* Redraw the whole screen if scrolling is pointless. */
2778         if (view->height < ABS(lines)) {
2779                 redraw_view(view);
2781         } else {
2782                 int line = lines > 0 ? view->height - lines : 0;
2783                 int end = line + ABS(lines);
2785                 scrollok(view->win, TRUE);
2786                 wscrl(view->win, lines);
2787                 scrollok(view->win, FALSE);
2789                 while (line < end && draw_view_line(view, line))
2790                         line++;
2792                 if (redraw_current_line)
2793                         draw_view_line(view, view->lineno - view->offset);
2794                 wnoutrefresh(view->win);
2795         }
2797         view->has_scrolled = TRUE;
2798         report("");
2801 /* Scroll frontend */
2802 static void
2803 scroll_view(struct view *view, enum request request)
2805         int lines = 1;
2807         assert(view_is_displayed(view));
2809         switch (request) {
2810         case REQ_SCROLL_LEFT:
2811                 if (view->yoffset == 0) {
2812                         report("Cannot scroll beyond the first column");
2813                         return;
2814                 }
2815                 if (view->yoffset <= apply_step(opt_hscroll, view->width))
2816                         view->yoffset = 0;
2817                 else
2818                         view->yoffset -= apply_step(opt_hscroll, view->width);
2819                 redraw_view_from(view, 0);
2820                 report("");
2821                 return;
2822         case REQ_SCROLL_RIGHT:
2823                 view->yoffset += apply_step(opt_hscroll, view->width);
2824                 redraw_view(view);
2825                 report("");
2826                 return;
2827         case REQ_SCROLL_PAGE_DOWN:
2828                 lines = view->height;
2829         case REQ_SCROLL_LINE_DOWN:
2830                 if (view->offset + lines > view->lines)
2831                         lines = view->lines - view->offset;
2833                 if (lines == 0 || view->offset + view->height >= view->lines) {
2834                         report("Cannot scroll beyond the last line");
2835                         return;
2836                 }
2837                 break;
2839         case REQ_SCROLL_PAGE_UP:
2840                 lines = view->height;
2841         case REQ_SCROLL_LINE_UP:
2842                 if (lines > view->offset)
2843                         lines = view->offset;
2845                 if (lines == 0) {
2846                         report("Cannot scroll beyond the first line");
2847                         return;
2848                 }
2850                 lines = -lines;
2851                 break;
2853         default:
2854                 die("request %d not handled in switch", request);
2855         }
2857         do_scroll_view(view, lines);
2860 /* Cursor moving */
2861 static void
2862 move_view(struct view *view, enum request request)
2864         int scroll_steps = 0;
2865         int steps;
2867         switch (request) {
2868         case REQ_MOVE_FIRST_LINE:
2869                 steps = -view->lineno;
2870                 break;
2872         case REQ_MOVE_LAST_LINE:
2873                 steps = view->lines - view->lineno - 1;
2874                 break;
2876         case REQ_MOVE_PAGE_UP:
2877                 steps = view->height > view->lineno
2878                       ? -view->lineno : -view->height;
2879                 break;
2881         case REQ_MOVE_PAGE_DOWN:
2882                 steps = view->lineno + view->height >= view->lines
2883                       ? view->lines - view->lineno - 1 : view->height;
2884                 break;
2886         case REQ_MOVE_UP:
2887                 steps = -1;
2888                 break;
2890         case REQ_MOVE_DOWN:
2891                 steps = 1;
2892                 break;
2894         default:
2895                 die("request %d not handled in switch", request);
2896         }
2898         if (steps <= 0 && view->lineno == 0) {
2899                 report("Cannot move beyond the first line");
2900                 return;
2902         } else if (steps >= 0 && view->lineno + 1 >= view->lines) {
2903                 report("Cannot move beyond the last line");
2904                 return;
2905         }
2907         /* Move the current line */
2908         view->lineno += steps;
2909         assert(0 <= view->lineno && view->lineno < view->lines);
2911         /* Check whether the view needs to be scrolled */
2912         if (view->lineno < view->offset ||
2913             view->lineno >= view->offset + view->height) {
2914                 scroll_steps = steps;
2915                 if (steps < 0 && -steps > view->offset) {
2916                         scroll_steps = -view->offset;
2918                 } else if (steps > 0) {
2919                         if (view->lineno == view->lines - 1 &&
2920                             view->lines > view->height) {
2921                                 scroll_steps = view->lines - view->offset - 1;
2922                                 if (scroll_steps >= view->height)
2923                                         scroll_steps -= view->height - 1;
2924                         }
2925                 }
2926         }
2928         if (!view_is_displayed(view)) {
2929                 view->offset += scroll_steps;
2930                 assert(0 <= view->offset && view->offset < view->lines);
2931                 view->ops->select(view, &view->line[view->lineno]);
2932                 return;
2933         }
2935         /* Repaint the old "current" line if we be scrolling */
2936         if (ABS(steps) < view->height)
2937                 draw_view_line(view, view->lineno - steps - view->offset);
2939         if (scroll_steps) {
2940                 do_scroll_view(view, scroll_steps);
2941                 return;
2942         }
2944         /* Draw the current line */
2945         draw_view_line(view, view->lineno - view->offset);
2947         wnoutrefresh(view->win);
2948         report("");
2952 /*
2953  * Searching
2954  */
2956 static void search_view(struct view *view, enum request request);
2958 static bool
2959 grep_text(struct view *view, const char *text[])
2961         regmatch_t pmatch;
2962         size_t i;
2964         for (i = 0; text[i]; i++)
2965                 if (*text[i] &&
2966                     regexec(view->regex, text[i], 1, &pmatch, 0) != REG_NOMATCH)
2967                         return TRUE;
2968         return FALSE;
2971 static void
2972 select_view_line(struct view *view, unsigned long lineno)
2974         unsigned long old_lineno = view->lineno;
2975         unsigned long old_offset = view->offset;
2977         if (goto_view_line(view, view->offset, lineno)) {
2978                 if (view_is_displayed(view)) {
2979                         if (old_offset != view->offset) {
2980                                 redraw_view(view);
2981                         } else {
2982                                 draw_view_line(view, old_lineno - view->offset);
2983                                 draw_view_line(view, view->lineno - view->offset);
2984                                 wnoutrefresh(view->win);
2985                         }
2986                 } else {
2987                         view->ops->select(view, &view->line[view->lineno]);
2988                 }
2989         }
2992 static void
2993 find_next(struct view *view, enum request request)
2995         unsigned long lineno = view->lineno;
2996         int direction;
2998         if (!*view->grep) {
2999                 if (!*opt_search)
3000                         report("No previous search");
3001                 else
3002                         search_view(view, request);
3003                 return;
3004         }
3006         switch (request) {
3007         case REQ_SEARCH:
3008         case REQ_FIND_NEXT:
3009                 direction = 1;
3010                 break;
3012         case REQ_SEARCH_BACK:
3013         case REQ_FIND_PREV:
3014                 direction = -1;
3015                 break;
3017         default:
3018                 return;
3019         }
3021         if (request == REQ_FIND_NEXT || request == REQ_FIND_PREV)
3022                 lineno += direction;
3024         /* Note, lineno is unsigned long so will wrap around in which case it
3025          * will become bigger than view->lines. */
3026         for (; lineno < view->lines; lineno += direction) {
3027                 if (view->ops->grep(view, &view->line[lineno])) {
3028                         select_view_line(view, lineno);
3029                         report("Line %ld matches '%s'", lineno + 1, view->grep);
3030                         return;
3031                 }
3032         }
3034         report("No match found for '%s'", view->grep);
3037 static void
3038 search_view(struct view *view, enum request request)
3040         int regex_err;
3042         if (view->regex) {
3043                 regfree(view->regex);
3044                 *view->grep = 0;
3045         } else {
3046                 view->regex = calloc(1, sizeof(*view->regex));
3047                 if (!view->regex)
3048                         return;
3049         }
3051         regex_err = regcomp(view->regex, opt_search, REG_EXTENDED);
3052         if (regex_err != 0) {
3053                 char buf[SIZEOF_STR] = "unknown error";
3055                 regerror(regex_err, view->regex, buf, sizeof(buf));
3056                 report("Search failed: %s", buf);
3057                 return;
3058         }
3060         string_copy(view->grep, opt_search);
3062         find_next(view, request);
3065 /*
3066  * Incremental updating
3067  */
3069 static void
3070 reset_view(struct view *view)
3072         int i;
3074         for (i = 0; i < view->lines; i++)
3075                 free(view->line[i].data);
3076         free(view->line);
3078         view->p_offset = view->offset;
3079         view->p_yoffset = view->yoffset;
3080         view->p_lineno = view->lineno;
3082         view->line = NULL;
3083         view->offset = 0;
3084         view->yoffset = 0;
3085         view->lines  = 0;
3086         view->lineno = 0;
3087         view->vid[0] = 0;
3088         view->update_secs = 0;
3091 static void
3092 free_argv(const char *argv[])
3094         int argc;
3096         for (argc = 0; argv[argc]; argc++)
3097                 free((void *) argv[argc]);
3100 static const char *
3101 format_arg(const char *name)
3103         static struct {
3104                 const char *name;
3105                 size_t namelen;
3106                 const char *value;
3107                 const char *value_if_empty;
3108         } vars[] = {
3109 #define FORMAT_VAR(name, value, value_if_empty) \
3110         { name, STRING_SIZE(name), value, value_if_empty }
3111                 FORMAT_VAR("%(directory)",      opt_path,       ""),
3112                 FORMAT_VAR("%(file)",           opt_file,       ""),
3113                 FORMAT_VAR("%(ref)",            opt_ref,        "HEAD"),
3114                 FORMAT_VAR("%(head)",           ref_head,       ""),
3115                 FORMAT_VAR("%(commit)",         ref_commit,     ""),
3116                 FORMAT_VAR("%(blob)",           ref_blob,       ""),
3117                 FORMAT_VAR("%(branch)",         ref_branch,     ""),
3118         };
3119         int i;
3121         for (i = 0; i < ARRAY_SIZE(vars); i++)
3122                 if (!strncmp(name, vars[i].name, vars[i].namelen))
3123                         return *vars[i].value ? vars[i].value : vars[i].value_if_empty;
3125         report("Unknown replacement: `%s`", name);
3126         return NULL;
3129 static bool
3130 format_argv(const char *dst_argv[], const char *src_argv[], enum format_flags flags)
3132         char buf[SIZEOF_STR];
3133         int argc;
3134         bool noreplace = flags == FORMAT_NONE;
3136         free_argv(dst_argv);
3138         for (argc = 0; src_argv[argc]; argc++) {
3139                 const char *arg = src_argv[argc];
3140                 size_t bufpos = 0;
3142                 while (arg) {
3143                         char *next = strstr(arg, "%(");
3144                         int len = next - arg;
3145                         const char *value;
3147                         if (!next || noreplace) {
3148                                 len = strlen(arg);
3149                                 value = "";
3151                         } else {
3152                                 value = format_arg(next);
3154                                 if (!value) {
3155                                         return FALSE;
3156                                 }
3157                         }
3159                         if (!string_format_from(buf, &bufpos, "%.*s%s", len, arg, value))
3160                                 return FALSE;
3162                         arg = next && !noreplace ? strchr(next, ')') + 1 : NULL;
3163                 }
3165                 dst_argv[argc] = strdup(buf);
3166                 if (!dst_argv[argc])
3167                         break;
3168         }
3170         dst_argv[argc] = NULL;
3172         return src_argv[argc] == NULL;
3175 static bool
3176 restore_view_position(struct view *view)
3178         if (!view->p_restore || (view->pipe && view->lines <= view->p_lineno))
3179                 return FALSE;
3181         /* Changing the view position cancels the restoring. */
3182         /* FIXME: Changing back to the first line is not detected. */
3183         if (view->offset != 0 || view->lineno != 0) {
3184                 view->p_restore = FALSE;
3185                 return FALSE;
3186         }
3188         if (goto_view_line(view, view->p_offset, view->p_lineno) &&
3189             view_is_displayed(view))
3190                 werase(view->win);
3192         view->yoffset = view->p_yoffset;
3193         view->p_restore = FALSE;
3195         return TRUE;
3198 static void
3199 end_update(struct view *view, bool force)
3201         if (!view->pipe)
3202                 return;
3203         while (!view->ops->read(view, NULL))
3204                 if (!force)
3205                         return;
3206         if (force)
3207                 io_kill(view->pipe);
3208         io_done(view->pipe);
3209         view->pipe = NULL;
3212 static void
3213 setup_update(struct view *view, const char *vid)
3215         reset_view(view);
3216         string_copy_rev(view->vid, vid);
3217         view->pipe = &view->io;
3218         view->start_time = time(NULL);
3221 static bool
3222 prepare_update(struct view *view, const char *argv[], const char *dir)
3224         if (view->pipe)
3225                 end_update(view, TRUE);
3226         return io_format(&view->io, dir, IO_RD, argv, FORMAT_NONE);
3229 static bool
3230 prepare_update_file(struct view *view, const char *name)
3232         if (view->pipe)
3233                 end_update(view, TRUE);
3234         return io_open(&view->io, "%s/%s", opt_cdup[0] ? opt_cdup : ".", name);
3237 static bool
3238 begin_update(struct view *view, bool refresh)
3240         if (view->pipe)
3241                 end_update(view, TRUE);
3243         if (!refresh) {
3244                 if (view->ops->prepare) {
3245                         if (!view->ops->prepare(view))
3246                                 return FALSE;
3247                 } else if (!io_format(&view->io, NULL, IO_RD, view->ops->argv, FORMAT_ALL)) {
3248                         return FALSE;
3249                 }
3251                 /* Put the current ref_* value to the view title ref
3252                  * member. This is needed by the blob view. Most other
3253                  * views sets it automatically after loading because the
3254                  * first line is a commit line. */
3255                 string_copy_rev(view->ref, view->id);
3256         }
3258         if (!io_start(&view->io))
3259                 return FALSE;
3261         setup_update(view, view->id);
3263         return TRUE;
3266 static bool
3267 update_view(struct view *view)
3269         char out_buffer[BUFSIZ * 2];
3270         char *line;
3271         /* Clear the view and redraw everything since the tree sorting
3272          * might have rearranged things. */
3273         bool redraw = view->lines == 0;
3274         bool can_read = TRUE;
3276         if (!view->pipe)
3277                 return TRUE;
3279         if (!io_can_read(view->pipe)) {
3280                 if (view->lines == 0 && view_is_displayed(view)) {
3281                         time_t secs = time(NULL) - view->start_time;
3283                         if (secs > 1 && secs > view->update_secs) {
3284                                 if (view->update_secs == 0)
3285                                         redraw_view(view);
3286                                 update_view_title(view);
3287                                 view->update_secs = secs;
3288                         }
3289                 }
3290                 return TRUE;
3291         }
3293         for (; (line = io_get(view->pipe, '\n', can_read)); can_read = FALSE) {
3294                 if (opt_iconv_in != ICONV_NONE) {
3295                         ICONV_CONST char *inbuf = line;
3296                         size_t inlen = strlen(line) + 1;
3298                         char *outbuf = out_buffer;
3299                         size_t outlen = sizeof(out_buffer);
3301                         size_t ret;
3303                         ret = iconv(opt_iconv_in, &inbuf, &inlen, &outbuf, &outlen);
3304                         if (ret != (size_t) -1)
3305                                 line = out_buffer;
3306                 }
3308                 if (!view->ops->read(view, line)) {
3309                         report("Allocation failure");
3310                         end_update(view, TRUE);
3311                         return FALSE;
3312                 }
3313         }
3315         {
3316                 unsigned long lines = view->lines;
3317                 int digits;
3319                 for (digits = 0; lines; digits++)
3320                         lines /= 10;
3322                 /* Keep the displayed view in sync with line number scaling. */
3323                 if (digits != view->digits) {
3324                         view->digits = digits;
3325                         if (opt_line_number || view == VIEW(REQ_VIEW_BLAME))
3326                                 redraw = TRUE;
3327                 }
3328         }
3330         if (io_error(view->pipe)) {
3331                 report("Failed to read: %s", io_strerror(view->pipe));
3332                 end_update(view, TRUE);
3334         } else if (io_eof(view->pipe)) {
3335                 report("");
3336                 end_update(view, FALSE);
3337         }
3339         if (restore_view_position(view))
3340                 redraw = TRUE;
3342         if (!view_is_displayed(view))
3343                 return TRUE;
3345         if (redraw)
3346                 redraw_view_from(view, 0);
3347         else
3348                 redraw_view_dirty(view);
3350         /* Update the title _after_ the redraw so that if the redraw picks up a
3351          * commit reference in view->ref it'll be available here. */
3352         update_view_title(view);
3353         return TRUE;
3356 DEFINE_ALLOCATOR(realloc_lines, struct line, 256)
3358 static struct line *
3359 add_line_data(struct view *view, void *data, enum line_type type)
3361         struct line *line;
3363         if (!realloc_lines(&view->line, view->lines, 1))
3364                 return NULL;
3366         line = &view->line[view->lines++];
3367         memset(line, 0, sizeof(*line));
3368         line->type = type;
3369         line->data = data;
3370         line->dirty = 1;
3372         return line;
3375 static struct line *
3376 add_line_text(struct view *view, const char *text, enum line_type type)
3378         char *data = text ? strdup(text) : NULL;
3380         return data ? add_line_data(view, data, type) : NULL;
3383 static struct line *
3384 add_line_format(struct view *view, enum line_type type, const char *fmt, ...)
3386         char buf[SIZEOF_STR];
3387         va_list args;
3389         va_start(args, fmt);
3390         if (vsnprintf(buf, sizeof(buf), fmt, args) >= sizeof(buf))
3391                 buf[0] = 0;
3392         va_end(args);
3394         return buf[0] ? add_line_text(view, buf, type) : NULL;
3397 /*
3398  * View opening
3399  */
3401 enum open_flags {
3402         OPEN_DEFAULT = 0,       /* Use default view switching. */
3403         OPEN_SPLIT = 1,         /* Split current view. */
3404         OPEN_RELOAD = 4,        /* Reload view even if it is the current. */
3405         OPEN_REFRESH = 16,      /* Refresh view using previous command. */
3406         OPEN_PREPARED = 32,     /* Open already prepared command. */
3407 };
3409 static void
3410 open_view(struct view *prev, enum request request, enum open_flags flags)
3412         bool split = !!(flags & OPEN_SPLIT);
3413         bool reload = !!(flags & (OPEN_RELOAD | OPEN_REFRESH | OPEN_PREPARED));
3414         bool nomaximize = !!(flags & OPEN_REFRESH);
3415         struct view *view = VIEW(request);
3416         int nviews = displayed_views();
3417         struct view *base_view = display[0];
3419         if (view == prev && nviews == 1 && !reload) {
3420                 report("Already in %s view", view->name);
3421                 return;
3422         }
3424         if (view->git_dir && !opt_git_dir[0]) {
3425                 report("The %s view is disabled in pager view", view->name);
3426                 return;
3427         }
3429         if (split) {
3430                 display[1] = view;
3431                 current_view = 1;
3432         } else if (!nomaximize) {
3433                 /* Maximize the current view. */
3434                 memset(display, 0, sizeof(display));
3435                 current_view = 0;
3436                 display[current_view] = view;
3437         }
3439         /* No parent signals that this is the first loaded view. */
3440         if (prev && view != prev) {
3441                 view->parent = prev;
3442         }
3444         /* Resize the view when switching between split- and full-screen,
3445          * or when switching between two different full-screen views. */
3446         if (nviews != displayed_views() ||
3447             (nviews == 1 && base_view != display[0]))
3448                 resize_display();
3450         if (view->ops->open) {
3451                 if (view->pipe)
3452                         end_update(view, TRUE);
3453                 if (!view->ops->open(view)) {
3454                         report("Failed to load %s view", view->name);
3455                         return;
3456                 }
3457                 restore_view_position(view);
3459         } else if ((reload || strcmp(view->vid, view->id)) &&
3460                    !begin_update(view, flags & (OPEN_REFRESH | OPEN_PREPARED))) {
3461                 report("Failed to load %s view", view->name);
3462                 return;
3463         }
3465         if (split && prev->lineno - prev->offset >= prev->height) {
3466                 /* Take the title line into account. */
3467                 int lines = prev->lineno - prev->offset - prev->height + 1;
3469                 /* Scroll the view that was split if the current line is
3470                  * outside the new limited view. */
3471                 do_scroll_view(prev, lines);
3472         }
3474         if (prev && view != prev && split && view_is_displayed(prev)) {
3475                 /* "Blur" the previous view. */
3476                 update_view_title(prev);
3477         }
3479         if (view->pipe && view->lines == 0) {
3480                 /* Clear the old view and let the incremental updating refill
3481                  * the screen. */
3482                 werase(view->win);
3483                 view->p_restore = flags & (OPEN_RELOAD | OPEN_REFRESH);
3484                 report("");
3485         } else if (view_is_displayed(view)) {
3486                 redraw_view(view);
3487                 report("");
3488         }
3491 static void
3492 open_external_viewer(const char *argv[], const char *dir)
3494         def_prog_mode();           /* save current tty modes */
3495         endwin();                  /* restore original tty modes */
3496         io_run_fg(argv, dir);
3497         fprintf(stderr, "Press Enter to continue");
3498         getc(opt_tty);
3499         reset_prog_mode();
3500         redraw_display(TRUE);
3503 static void
3504 open_mergetool(const char *file)
3506         const char *mergetool_argv[] = { "git", "mergetool", file, NULL };
3508         open_external_viewer(mergetool_argv, opt_cdup);
3511 static void
3512 open_editor(const char *file)
3514         const char *editor_argv[] = { "vi", file, NULL };
3515         const char *editor;
3517         editor = getenv("GIT_EDITOR");
3518         if (!editor && *opt_editor)
3519                 editor = opt_editor;
3520         if (!editor)
3521                 editor = getenv("VISUAL");
3522         if (!editor)
3523                 editor = getenv("EDITOR");
3524         if (!editor)
3525                 editor = "vi";
3527         editor_argv[0] = editor;
3528         open_external_viewer(editor_argv, opt_cdup);
3531 static void
3532 open_run_request(enum request request)
3534         struct run_request *req = get_run_request(request);
3535         const char *argv[ARRAY_SIZE(req->argv)] = { NULL };
3537         if (!req) {
3538                 report("Unknown run request");
3539                 return;
3540         }
3542         if (format_argv(argv, req->argv, FORMAT_ALL))
3543                 open_external_viewer(argv, NULL);
3544         free_argv(argv);
3547 /*
3548  * User request switch noodle
3549  */
3551 static int
3552 view_driver(struct view *view, enum request request)
3554         int i;
3556         if (request == REQ_NONE)
3557                 return TRUE;
3559         if (request > REQ_NONE) {
3560                 open_run_request(request);
3561                 /* FIXME: When all views can refresh always do this. */
3562                 if (view->refresh)
3563                         request = REQ_REFRESH;
3564                 else
3565                         return TRUE;
3566         }
3568         if (view && view->lines) {
3569                 request = view->ops->request(view, request, &view->line[view->lineno]);
3570                 if (request == REQ_NONE)
3571                         return TRUE;
3572         }
3574         switch (request) {
3575         case REQ_MOVE_UP:
3576         case REQ_MOVE_DOWN:
3577         case REQ_MOVE_PAGE_UP:
3578         case REQ_MOVE_PAGE_DOWN:
3579         case REQ_MOVE_FIRST_LINE:
3580         case REQ_MOVE_LAST_LINE:
3581                 move_view(view, request);
3582                 break;
3584         case REQ_SCROLL_LEFT:
3585         case REQ_SCROLL_RIGHT:
3586         case REQ_SCROLL_LINE_DOWN:
3587         case REQ_SCROLL_LINE_UP:
3588         case REQ_SCROLL_PAGE_DOWN:
3589         case REQ_SCROLL_PAGE_UP:
3590                 scroll_view(view, request);
3591                 break;
3593         case REQ_VIEW_BLAME:
3594                 if (!opt_file[0]) {
3595                         report("No file chosen, press %s to open tree view",
3596                                get_key(view->keymap, REQ_VIEW_TREE));
3597                         break;
3598                 }
3599                 open_view(view, request, OPEN_DEFAULT);
3600                 break;
3602         case REQ_VIEW_BLOB:
3603                 if (!ref_blob[0]) {
3604                         report("No file chosen, press %s to open tree view",
3605                                get_key(view->keymap, REQ_VIEW_TREE));
3606                         break;
3607                 }
3608                 open_view(view, request, OPEN_DEFAULT);
3609                 break;
3611         case REQ_VIEW_PAGER:
3612                 if (!VIEW(REQ_VIEW_PAGER)->pipe && !VIEW(REQ_VIEW_PAGER)->lines) {
3613                         report("No pager content, press %s to run command from prompt",
3614                                get_key(view->keymap, REQ_PROMPT));
3615                         break;
3616                 }
3617                 open_view(view, request, OPEN_DEFAULT);
3618                 break;
3620         case REQ_VIEW_STAGE:
3621                 if (!VIEW(REQ_VIEW_STAGE)->lines) {
3622                         report("No stage content, press %s to open the status view and choose file",
3623                                get_key(view->keymap, REQ_VIEW_STATUS));
3624                         break;
3625                 }
3626                 open_view(view, request, OPEN_DEFAULT);
3627                 break;
3629         case REQ_VIEW_STATUS:
3630                 if (opt_is_inside_work_tree == FALSE) {
3631                         report("The status view requires a working tree");
3632                         break;
3633                 }
3634                 open_view(view, request, OPEN_DEFAULT);
3635                 break;
3637         case REQ_VIEW_MAIN:
3638         case REQ_VIEW_DIFF:
3639         case REQ_VIEW_LOG:
3640         case REQ_VIEW_TREE:
3641         case REQ_VIEW_HELP:
3642         case REQ_VIEW_BRANCH:
3643                 open_view(view, request, OPEN_DEFAULT);
3644                 break;
3646         case REQ_NEXT:
3647         case REQ_PREVIOUS:
3648                 request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
3650                 if ((view == VIEW(REQ_VIEW_DIFF) &&
3651                      view->parent == VIEW(REQ_VIEW_MAIN)) ||
3652                    (view == VIEW(REQ_VIEW_DIFF) &&
3653                      view->parent == VIEW(REQ_VIEW_BLAME)) ||
3654                    (view == VIEW(REQ_VIEW_STAGE) &&
3655                      view->parent == VIEW(REQ_VIEW_STATUS)) ||
3656                    (view == VIEW(REQ_VIEW_BLOB) &&
3657                      view->parent == VIEW(REQ_VIEW_TREE)) ||
3658                    (view == VIEW(REQ_VIEW_MAIN) &&
3659                      view->parent == VIEW(REQ_VIEW_BRANCH))) {
3660                         int line;
3662                         view = view->parent;
3663                         line = view->lineno;
3664                         move_view(view, request);
3665                         if (view_is_displayed(view))
3666                                 update_view_title(view);
3667                         if (line != view->lineno)
3668                                 view->ops->request(view, REQ_ENTER,
3669                                                    &view->line[view->lineno]);
3671                 } else {
3672                         move_view(view, request);
3673                 }
3674                 break;
3676         case REQ_VIEW_NEXT:
3677         {
3678                 int nviews = displayed_views();
3679                 int next_view = (current_view + 1) % nviews;
3681                 if (next_view == current_view) {
3682                         report("Only one view is displayed");
3683                         break;
3684                 }
3686                 current_view = next_view;
3687                 /* Blur out the title of the previous view. */
3688                 update_view_title(view);
3689                 report("");
3690                 break;
3691         }
3692         case REQ_REFRESH:
3693                 report("Refreshing is not yet supported for the %s view", view->name);
3694                 break;
3696         case REQ_MAXIMIZE:
3697                 if (displayed_views() == 2)
3698                         maximize_view(view);
3699                 break;
3701         case REQ_OPTIONS:
3702                 open_option_menu();
3703                 break;
3705         case REQ_TOGGLE_LINENO:
3706                 toggle_view_option(&opt_line_number, "line numbers");
3707                 break;
3709         case REQ_TOGGLE_DATE:
3710                 toggle_date();
3711                 break;
3713         case REQ_TOGGLE_AUTHOR:
3714                 toggle_author();
3715                 break;
3717         case REQ_TOGGLE_REV_GRAPH:
3718                 toggle_view_option(&opt_rev_graph, "revision graph display");
3719                 break;
3721         case REQ_TOGGLE_REFS:
3722                 toggle_view_option(&opt_show_refs, "reference display");
3723                 break;
3725         case REQ_TOGGLE_SORT_FIELD:
3726         case REQ_TOGGLE_SORT_ORDER:
3727                 report("Sorting is not yet supported for the %s view", view->name);
3728                 break;
3730         case REQ_SEARCH:
3731         case REQ_SEARCH_BACK:
3732                 search_view(view, request);
3733                 break;
3735         case REQ_FIND_NEXT:
3736         case REQ_FIND_PREV:
3737                 find_next(view, request);
3738                 break;
3740         case REQ_STOP_LOADING:
3741                 for (i = 0; i < ARRAY_SIZE(views); i++) {
3742                         view = &views[i];
3743                         if (view->pipe)
3744                                 report("Stopped loading the %s view", view->name),
3745                         end_update(view, TRUE);
3746                 }
3747                 break;
3749         case REQ_SHOW_VERSION:
3750                 report("tig-%s (built %s)", TIG_VERSION, __DATE__);
3751                 return TRUE;
3753         case REQ_SCREEN_REDRAW:
3754                 redraw_display(TRUE);
3755                 break;
3757         case REQ_EDIT:
3758                 report("Nothing to edit");
3759                 break;
3761         case REQ_ENTER:
3762                 report("Nothing to enter");
3763                 break;
3765         case REQ_VIEW_CLOSE:
3766                 /* XXX: Mark closed views by letting view->parent point to the
3767                  * view itself. Parents to closed view should never be
3768                  * followed. */
3769                 if (view->parent &&
3770                     view->parent->parent != view->parent) {
3771                         maximize_view(view->parent);
3772                         view->parent = view;
3773                         break;
3774                 }
3775                 /* Fall-through */
3776         case REQ_QUIT:
3777                 return FALSE;
3779         default:
3780                 report("Unknown key, press %s for help",
3781                        get_key(view->keymap, REQ_VIEW_HELP));
3782                 return TRUE;
3783         }
3785         return TRUE;
3789 /*
3790  * View backend utilities
3791  */
3793 enum sort_field {
3794         ORDERBY_NAME,
3795         ORDERBY_DATE,
3796         ORDERBY_AUTHOR,
3797 };
3799 struct sort_state {
3800         const enum sort_field *fields;
3801         size_t size, current;
3802         bool reverse;
3803 };
3805 #define SORT_STATE(fields) { fields, ARRAY_SIZE(fields), 0 }
3806 #define get_sort_field(state) ((state).fields[(state).current])
3807 #define sort_order(state, result) ((state).reverse ? -(result) : (result))
3809 static void
3810 sort_view(struct view *view, enum request request, struct sort_state *state,
3811           int (*compare)(const void *, const void *))
3813         switch (request) {
3814         case REQ_TOGGLE_SORT_FIELD:
3815                 state->current = (state->current + 1) % state->size;
3816                 break;
3818         case REQ_TOGGLE_SORT_ORDER:
3819                 state->reverse = !state->reverse;
3820                 break;
3821         default:
3822                 die("Not a sort request");
3823         }
3825         qsort(view->line, view->lines, sizeof(*view->line), compare);
3826         redraw_view(view);
3829 DEFINE_ALLOCATOR(realloc_authors, const char *, 256)
3831 /* Small author cache to reduce memory consumption. It uses binary
3832  * search to lookup or find place to position new entries. No entries
3833  * are ever freed. */
3834 static const char *
3835 get_author(const char *name)
3837         static const char **authors;
3838         static size_t authors_size;
3839         int from = 0, to = authors_size - 1;
3841         while (from <= to) {
3842                 size_t pos = (to + from) / 2;
3843                 int cmp = strcmp(name, authors[pos]);
3845                 if (!cmp)
3846                         return authors[pos];
3848                 if (cmp < 0)
3849                         to = pos - 1;
3850                 else
3851                         from = pos + 1;
3852         }
3854         if (!realloc_authors(&authors, authors_size, 1))
3855                 return NULL;
3856         name = strdup(name);
3857         if (!name)
3858                 return NULL;
3860         memmove(authors + from + 1, authors + from, (authors_size - from) * sizeof(*authors));
3861         authors[from] = name;
3862         authors_size++;
3864         return name;
3867 static void
3868 parse_timesec(struct time *time, const char *sec)
3870         time->sec = (time_t) atol(sec);
3873 static void
3874 parse_timezone(struct time *time, const char *zone)
3876         long tz;
3878         tz  = ('0' - zone[1]) * 60 * 60 * 10;
3879         tz += ('0' - zone[2]) * 60 * 60;
3880         tz += ('0' - zone[3]) * 60;
3881         tz += ('0' - zone[4]);
3883         if (zone[0] == '-')
3884                 tz = -tz;
3886         time->tz = tz;
3887         time->sec -= tz;
3890 /* Parse author lines where the name may be empty:
3891  *      author  <email@address.tld> 1138474660 +0100
3892  */
3893 static void
3894 parse_author_line(char *ident, const char **author, struct time *time)
3896         char *nameend = strchr(ident, '<');
3897         char *emailend = strchr(ident, '>');
3899         if (nameend && emailend)
3900                 *nameend = *emailend = 0;
3901         ident = chomp_string(ident);
3902         if (!*ident) {
3903                 if (nameend)
3904                         ident = chomp_string(nameend + 1);
3905                 if (!*ident)
3906                         ident = "Unknown";
3907         }
3909         *author = get_author(ident);
3911         /* Parse epoch and timezone */
3912         if (emailend && emailend[1] == ' ') {
3913                 char *secs = emailend + 2;
3914                 char *zone = strchr(secs, ' ');
3916                 parse_timesec(time, secs);
3918                 if (zone && strlen(zone) == STRING_SIZE(" +0700"))
3919                         parse_timezone(time, zone + 1);
3920         }
3923 static bool
3924 open_commit_parent_menu(char buf[SIZEOF_STR], int *parents)
3926         char rev[SIZEOF_REV];
3927         const char *revlist_argv[] = {
3928                 "git", "log", "--no-color", "-1", "--pretty=format:%s", rev, NULL
3929         };
3930         struct menu_item *items;
3931         char text[SIZEOF_STR];
3932         bool ok = TRUE;
3933         int i;
3935         items = calloc(*parents + 1, sizeof(*items));
3936         if (!items)
3937                 return FALSE;
3939         for (i = 0; i < *parents; i++) {
3940                 string_copy_rev(rev, &buf[SIZEOF_REV * i]);
3941                 if (!io_run_buf(revlist_argv, text, sizeof(text)) ||
3942                     !(items[i].text = strdup(text))) {
3943                         ok = FALSE;
3944                         break;
3945                 }
3946         }
3948         if (ok) {
3949                 *parents = 0;
3950                 ok = prompt_menu("Select parent", items, parents);
3951         }
3952         for (i = 0; items[i].text; i++)
3953                 free((char *) items[i].text);
3954         free(items);
3955         return ok;
3958 static bool
3959 select_commit_parent(const char *id, char rev[SIZEOF_REV], const char *path)
3961         char buf[SIZEOF_STR * 4];
3962         const char *revlist_argv[] = {
3963                 "git", "log", "--no-color", "-1",
3964                         "--pretty=format:%P", id, "--", path, NULL
3965         };
3966         int parents;
3968         if (!io_run_buf(revlist_argv, buf, sizeof(buf)) ||
3969             (parents = strlen(buf) / 40) < 0) {
3970                 report("Failed to get parent information");
3971                 return FALSE;
3973         } else if (parents == 0) {
3974                 if (path)
3975                         report("Path '%s' does not exist in the parent", path);
3976                 else
3977                         report("The selected commit has no parents");
3978                 return FALSE;
3979         }
3981         if (parents > 1 && !open_commit_parent_menu(buf, &parents))
3982                 return FALSE;
3984         string_copy_rev(rev, &buf[41 * parents]);
3985         return TRUE;
3988 /*
3989  * Pager backend
3990  */
3992 static bool
3993 pager_draw(struct view *view, struct line *line, unsigned int lineno)
3995         char text[SIZEOF_STR];
3997         if (opt_line_number && draw_lineno(view, lineno))
3998                 return TRUE;
4000         string_expand(text, sizeof(text), line->data, opt_tab_size);
4001         draw_text(view, line->type, text, TRUE);
4002         return TRUE;
4005 static bool
4006 add_describe_ref(char *buf, size_t *bufpos, const char *commit_id, const char *sep)
4008         const char *describe_argv[] = { "git", "describe", commit_id, NULL };
4009         char ref[SIZEOF_STR];
4011         if (!io_run_buf(describe_argv, ref, sizeof(ref)) || !*ref)
4012                 return TRUE;
4014         /* This is the only fatal call, since it can "corrupt" the buffer. */
4015         if (!string_nformat(buf, SIZEOF_STR, bufpos, "%s%s", sep, ref))
4016                 return FALSE;
4018         return TRUE;
4021 static void
4022 add_pager_refs(struct view *view, struct line *line)
4024         char buf[SIZEOF_STR];
4025         char *commit_id = (char *)line->data + STRING_SIZE("commit ");
4026         struct ref_list *list;
4027         size_t bufpos = 0, i;
4028         const char *sep = "Refs: ";
4029         bool is_tag = FALSE;
4031         assert(line->type == LINE_COMMIT);
4033         list = get_ref_list(commit_id);
4034         if (!list) {
4035                 if (view == VIEW(REQ_VIEW_DIFF))
4036                         goto try_add_describe_ref;
4037                 return;
4038         }
4040         for (i = 0; i < list->size; i++) {
4041                 struct ref *ref = list->refs[i];
4042                 const char *fmt = ref->tag    ? "%s[%s]" :
4043                                   ref->remote ? "%s<%s>" : "%s%s";
4045                 if (!string_format_from(buf, &bufpos, fmt, sep, ref->name))
4046                         return;
4047                 sep = ", ";
4048                 if (ref->tag)
4049                         is_tag = TRUE;
4050         }
4052         if (!is_tag && view == VIEW(REQ_VIEW_DIFF)) {
4053 try_add_describe_ref:
4054                 /* Add <tag>-g<commit_id> "fake" reference. */
4055                 if (!add_describe_ref(buf, &bufpos, commit_id, sep))
4056                         return;
4057         }
4059         if (bufpos == 0)
4060                 return;
4062         add_line_text(view, buf, LINE_PP_REFS);
4065 static bool
4066 pager_read(struct view *view, char *data)
4068         struct line *line;
4070         if (!data)
4071                 return TRUE;
4073         line = add_line_text(view, data, get_line_type(data));
4074         if (!line)
4075                 return FALSE;
4077         if (line->type == LINE_COMMIT &&
4078             (view == VIEW(REQ_VIEW_DIFF) ||
4079              view == VIEW(REQ_VIEW_LOG)))
4080                 add_pager_refs(view, line);
4082         return TRUE;
4085 static enum request
4086 pager_request(struct view *view, enum request request, struct line *line)
4088         int split = 0;
4090         if (request != REQ_ENTER)
4091                 return request;
4093         if (line->type == LINE_COMMIT &&
4094            (view == VIEW(REQ_VIEW_LOG) ||
4095             view == VIEW(REQ_VIEW_PAGER))) {
4096                 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
4097                 split = 1;
4098         }
4100         /* Always scroll the view even if it was split. That way
4101          * you can use Enter to scroll through the log view and
4102          * split open each commit diff. */
4103         scroll_view(view, REQ_SCROLL_LINE_DOWN);
4105         /* FIXME: A minor workaround. Scrolling the view will call report("")
4106          * but if we are scrolling a non-current view this won't properly
4107          * update the view title. */
4108         if (split)
4109                 update_view_title(view);
4111         return REQ_NONE;
4114 static bool
4115 pager_grep(struct view *view, struct line *line)
4117         const char *text[] = { line->data, NULL };
4119         return grep_text(view, text);
4122 static void
4123 pager_select(struct view *view, struct line *line)
4125         if (line->type == LINE_COMMIT) {
4126                 char *text = (char *)line->data + STRING_SIZE("commit ");
4128                 if (view != VIEW(REQ_VIEW_PAGER))
4129                         string_copy_rev(view->ref, text);
4130                 string_copy_rev(ref_commit, text);
4131         }
4134 static struct view_ops pager_ops = {
4135         "line",
4136         NULL,
4137         NULL,
4138         pager_read,
4139         pager_draw,
4140         pager_request,
4141         pager_grep,
4142         pager_select,
4143 };
4145 static const char *log_argv[SIZEOF_ARG] = {
4146         "git", "log", "--no-color", "--cc", "--stat", "-n100", "%(head)", NULL
4147 };
4149 static enum request
4150 log_request(struct view *view, enum request request, struct line *line)
4152         switch (request) {
4153         case REQ_REFRESH:
4154                 load_refs();
4155                 open_view(view, REQ_VIEW_LOG, OPEN_REFRESH);
4156                 return REQ_NONE;
4157         default:
4158                 return pager_request(view, request, line);
4159         }
4162 static struct view_ops log_ops = {
4163         "line",
4164         log_argv,
4165         NULL,
4166         pager_read,
4167         pager_draw,
4168         log_request,
4169         pager_grep,
4170         pager_select,
4171 };
4173 static const char *diff_argv[SIZEOF_ARG] = {
4174         "git", "show", "--pretty=fuller", "--no-color", "--root",
4175                 "--patch-with-stat", "--find-copies-harder", "-C", "%(commit)", NULL
4176 };
4178 static struct view_ops diff_ops = {
4179         "line",
4180         diff_argv,
4181         NULL,
4182         pager_read,
4183         pager_draw,
4184         pager_request,
4185         pager_grep,
4186         pager_select,
4187 };
4189 /*
4190  * Help backend
4191  */
4193 static bool help_keymap_hidden[ARRAY_SIZE(keymap_table)];
4195 static bool
4196 help_open_keymap_title(struct view *view, enum keymap keymap)
4198         struct line *line;
4200         line = add_line_format(view, LINE_HELP_KEYMAP, "[%c] %s bindings",
4201                                help_keymap_hidden[keymap] ? '+' : '-',
4202                                enum_name(keymap_table[keymap]));
4203         if (line)
4204                 line->other = keymap;
4206         return help_keymap_hidden[keymap];
4209 static void
4210 help_open_keymap(struct view *view, enum keymap keymap)
4212         const char *group = NULL;
4213         char buf[SIZEOF_STR];
4214         size_t bufpos;
4215         bool add_title = TRUE;
4216         int i;
4218         for (i = 0; i < ARRAY_SIZE(req_info); i++) {
4219                 const char *key = NULL;
4221                 if (req_info[i].request == REQ_NONE)
4222                         continue;
4224                 if (!req_info[i].request) {
4225                         group = req_info[i].help;
4226                         continue;
4227                 }
4229                 key = get_keys(keymap, req_info[i].request, TRUE);
4230                 if (!key || !*key)
4231                         continue;
4233                 if (add_title && help_open_keymap_title(view, keymap))
4234                         return;
4235                 add_title = FALSE;
4237                 if (group) {
4238                         add_line_text(view, group, LINE_HELP_GROUP);
4239                         group = NULL;
4240                 }
4242                 add_line_format(view, LINE_DEFAULT, "    %-25s %-20s %s", key,
4243                                 enum_name(req_info[i]), req_info[i].help);
4244         }
4246         group = "External commands:";
4248         for (i = 0; i < run_requests; i++) {
4249                 struct run_request *req = get_run_request(REQ_NONE + i + 1);
4250                 const char *key;
4251                 int argc;
4253                 if (!req || req->keymap != keymap)
4254                         continue;
4256                 key = get_key_name(req->key);
4257                 if (!*key)
4258                         key = "(no key defined)";
4260                 if (add_title && help_open_keymap_title(view, keymap))
4261                         return;
4262                 if (group) {
4263                         add_line_text(view, group, LINE_HELP_GROUP);
4264                         group = NULL;
4265                 }
4267                 for (bufpos = 0, argc = 0; req->argv[argc]; argc++)
4268                         if (!string_format_from(buf, &bufpos, "%s%s",
4269                                                 argc ? " " : "", req->argv[argc]))
4270                                 return;
4272                 add_line_format(view, LINE_DEFAULT, "    %-25s `%s`", key, buf);
4273         }
4276 static bool
4277 help_open(struct view *view)
4279         enum keymap keymap;
4281         reset_view(view);
4282         add_line_text(view, "Quick reference for tig keybindings:", LINE_DEFAULT);
4283         add_line_text(view, "", LINE_DEFAULT);
4285         for (keymap = 0; keymap < ARRAY_SIZE(keymap_table); keymap++)
4286                 help_open_keymap(view, keymap);
4288         return TRUE;
4291 static enum request
4292 help_request(struct view *view, enum request request, struct line *line)
4294         switch (request) {
4295         case REQ_ENTER:
4296                 if (line->type == LINE_HELP_KEYMAP) {
4297                         help_keymap_hidden[line->other] =
4298                                 !help_keymap_hidden[line->other];
4299                         view->p_restore = TRUE;
4300                         open_view(view, REQ_VIEW_HELP, OPEN_REFRESH);
4301                 }
4303                 return REQ_NONE;
4304         default:
4305                 return pager_request(view, request, line);
4306         }
4309 static struct view_ops help_ops = {
4310         "line",
4311         NULL,
4312         help_open,
4313         NULL,
4314         pager_draw,
4315         help_request,
4316         pager_grep,
4317         pager_select,
4318 };
4321 /*
4322  * Tree backend
4323  */
4325 struct tree_stack_entry {
4326         struct tree_stack_entry *prev;  /* Entry below this in the stack */
4327         unsigned long lineno;           /* Line number to restore */
4328         char *name;                     /* Position of name in opt_path */
4329 };
4331 /* The top of the path stack. */
4332 static struct tree_stack_entry *tree_stack = NULL;
4333 unsigned long tree_lineno = 0;
4335 static void
4336 pop_tree_stack_entry(void)
4338         struct tree_stack_entry *entry = tree_stack;
4340         tree_lineno = entry->lineno;
4341         entry->name[0] = 0;
4342         tree_stack = entry->prev;
4343         free(entry);
4346 static void
4347 push_tree_stack_entry(const char *name, unsigned long lineno)
4349         struct tree_stack_entry *entry = calloc(1, sizeof(*entry));
4350         size_t pathlen = strlen(opt_path);
4352         if (!entry)
4353                 return;
4355         entry->prev = tree_stack;
4356         entry->name = opt_path + pathlen;
4357         tree_stack = entry;
4359         if (!string_format_from(opt_path, &pathlen, "%s/", name)) {
4360                 pop_tree_stack_entry();
4361                 return;
4362         }
4364         /* Move the current line to the first tree entry. */
4365         tree_lineno = 1;
4366         entry->lineno = lineno;
4369 /* Parse output from git-ls-tree(1):
4370  *
4371  * 100644 blob f931e1d229c3e185caad4449bf5b66ed72462657 tig.c
4372  */
4374 #define SIZEOF_TREE_ATTR \
4375         STRING_SIZE("100644 blob f931e1d229c3e185caad4449bf5b66ed72462657\t")
4377 #define SIZEOF_TREE_MODE \
4378         STRING_SIZE("100644 ")
4380 #define TREE_ID_OFFSET \
4381         STRING_SIZE("100644 blob ")
4383 struct tree_entry {
4384         char id[SIZEOF_REV];
4385         mode_t mode;
4386         struct time time;               /* Date from the author ident. */
4387         const char *author;             /* Author of the commit. */
4388         char name[1];
4389 };
4391 static const char *
4392 tree_path(const struct line *line)
4394         return ((struct tree_entry *) line->data)->name;
4397 static int
4398 tree_compare_entry(const struct line *line1, const struct line *line2)
4400         if (line1->type != line2->type)
4401                 return line1->type == LINE_TREE_DIR ? -1 : 1;
4402         return strcmp(tree_path(line1), tree_path(line2));
4405 static const enum sort_field tree_sort_fields[] = {
4406         ORDERBY_NAME, ORDERBY_DATE, ORDERBY_AUTHOR
4407 };
4408 static struct sort_state tree_sort_state = SORT_STATE(tree_sort_fields);
4410 static int
4411 tree_compare(const void *l1, const void *l2)
4413         const struct line *line1 = (const struct line *) l1;
4414         const struct line *line2 = (const struct line *) l2;
4415         const struct tree_entry *entry1 = ((const struct line *) l1)->data;
4416         const struct tree_entry *entry2 = ((const struct line *) l2)->data;
4418         if (line1->type == LINE_TREE_HEAD)
4419                 return -1;
4420         if (line2->type == LINE_TREE_HEAD)
4421                 return 1;
4423         switch (get_sort_field(tree_sort_state)) {
4424         case ORDERBY_DATE:
4425                 return sort_order(tree_sort_state, timecmp(&entry1->time, &entry2->time));
4427         case ORDERBY_AUTHOR:
4428                 return sort_order(tree_sort_state, strcmp(entry1->author, entry2->author));
4430         case ORDERBY_NAME:
4431         default:
4432                 return sort_order(tree_sort_state, tree_compare_entry(line1, line2));
4433         }
4437 static struct line *
4438 tree_entry(struct view *view, enum line_type type, const char *path,
4439            const char *mode, const char *id)
4441         struct tree_entry *entry = calloc(1, sizeof(*entry) + strlen(path));
4442         struct line *line = entry ? add_line_data(view, entry, type) : NULL;
4444         if (!entry || !line) {
4445                 free(entry);
4446                 return NULL;
4447         }
4449         strncpy(entry->name, path, strlen(path));
4450         if (mode)
4451                 entry->mode = strtoul(mode, NULL, 8);
4452         if (id)
4453                 string_copy_rev(entry->id, id);
4455         return line;
4458 static bool
4459 tree_read_date(struct view *view, char *text, bool *read_date)
4461         static const char *author_name;
4462         static struct time author_time;
4464         if (!text && *read_date) {
4465                 *read_date = FALSE;
4466                 return TRUE;
4468         } else if (!text) {
4469                 char *path = *opt_path ? opt_path : ".";
4470                 /* Find next entry to process */
4471                 const char *log_file[] = {
4472                         "git", "log", "--no-color", "--pretty=raw",
4473                                 "--cc", "--raw", view->id, "--", path, NULL
4474                 };
4475                 struct io io = {};
4477                 if (!view->lines) {
4478                         tree_entry(view, LINE_TREE_HEAD, opt_path, NULL, NULL);
4479                         report("Tree is empty");
4480                         return TRUE;
4481                 }
4483                 if (!io_run_rd(&io, log_file, opt_cdup, FORMAT_NONE)) {
4484                         report("Failed to load tree data");
4485                         return TRUE;
4486                 }
4488                 io_done(view->pipe);
4489                 view->io = io;
4490                 *read_date = TRUE;
4491                 return FALSE;
4493         } else if (*text == 'a' && get_line_type(text) == LINE_AUTHOR) {
4494                 parse_author_line(text + STRING_SIZE("author "),
4495                                   &author_name, &author_time);
4497         } else if (*text == ':') {
4498                 char *pos;
4499                 size_t annotated = 1;
4500                 size_t i;
4502                 pos = strchr(text, '\t');
4503                 if (!pos)
4504                         return TRUE;
4505                 text = pos + 1;
4506                 if (*opt_path && !strncmp(text, opt_path, strlen(opt_path)))
4507                         text += strlen(opt_path);
4508                 pos = strchr(text, '/');
4509                 if (pos)
4510                         *pos = 0;
4512                 for (i = 1; i < view->lines; i++) {
4513                         struct line *line = &view->line[i];
4514                         struct tree_entry *entry = line->data;
4516                         annotated += !!entry->author;
4517                         if (entry->author || strcmp(entry->name, text))
4518                                 continue;
4520                         entry->author = author_name;
4521                         entry->time = author_time;
4522                         line->dirty = 1;
4523                         break;
4524                 }
4526                 if (annotated == view->lines)
4527                         io_kill(view->pipe);
4528         }
4529         return TRUE;
4532 static bool
4533 tree_read(struct view *view, char *text)
4535         static bool read_date = FALSE;
4536         struct tree_entry *data;
4537         struct line *entry, *line;
4538         enum line_type type;
4539         size_t textlen = text ? strlen(text) : 0;
4540         char *path = text + SIZEOF_TREE_ATTR;
4542         if (read_date || !text)
4543                 return tree_read_date(view, text, &read_date);
4545         if (textlen <= SIZEOF_TREE_ATTR)
4546                 return FALSE;
4547         if (view->lines == 0 &&
4548             !tree_entry(view, LINE_TREE_HEAD, opt_path, NULL, NULL))
4549                 return FALSE;
4551         /* Strip the path part ... */
4552         if (*opt_path) {
4553                 size_t pathlen = textlen - SIZEOF_TREE_ATTR;
4554                 size_t striplen = strlen(opt_path);
4556                 if (pathlen > striplen)
4557                         memmove(path, path + striplen,
4558                                 pathlen - striplen + 1);
4560                 /* Insert "link" to parent directory. */
4561                 if (view->lines == 1 &&
4562                     !tree_entry(view, LINE_TREE_DIR, "..", "040000", view->ref))
4563                         return FALSE;
4564         }
4566         type = text[SIZEOF_TREE_MODE] == 't' ? LINE_TREE_DIR : LINE_TREE_FILE;
4567         entry = tree_entry(view, type, path, text, text + TREE_ID_OFFSET);
4568         if (!entry)
4569                 return FALSE;
4570         data = entry->data;
4572         /* Skip "Directory ..." and ".." line. */
4573         for (line = &view->line[1 + !!*opt_path]; line < entry; line++) {
4574                 if (tree_compare_entry(line, entry) <= 0)
4575                         continue;
4577                 memmove(line + 1, line, (entry - line) * sizeof(*entry));
4579                 line->data = data;
4580                 line->type = type;
4581                 for (; line <= entry; line++)
4582                         line->dirty = line->cleareol = 1;
4583                 return TRUE;
4584         }
4586         if (tree_lineno > view->lineno) {
4587                 view->lineno = tree_lineno;
4588                 tree_lineno = 0;
4589         }
4591         return TRUE;
4594 static bool
4595 tree_draw(struct view *view, struct line *line, unsigned int lineno)
4597         struct tree_entry *entry = line->data;
4599         if (line->type == LINE_TREE_HEAD) {
4600                 if (draw_text(view, line->type, "Directory path /", TRUE))
4601                         return TRUE;
4602         } else {
4603                 if (draw_mode(view, entry->mode))
4604                         return TRUE;
4606                 if (opt_author && draw_author(view, entry->author))
4607                         return TRUE;
4609                 if (opt_date && draw_date(view, &entry->time))
4610                         return TRUE;
4611         }
4612         if (draw_text(view, line->type, entry->name, TRUE))
4613                 return TRUE;
4614         return TRUE;
4617 static void
4618 open_blob_editor()
4620         char file[SIZEOF_STR] = "/tmp/tigblob.XXXXXX";
4621         int fd = mkstemp(file);
4623         if (fd == -1)
4624                 report("Failed to create temporary file");
4625         else if (!io_run_append(blob_ops.argv, FORMAT_ALL, fd))
4626                 report("Failed to save blob data to file");
4627         else
4628                 open_editor(file);
4629         if (fd != -1)
4630                 unlink(file);
4633 static enum request
4634 tree_request(struct view *view, enum request request, struct line *line)
4636         enum open_flags flags;
4638         switch (request) {
4639         case REQ_VIEW_BLAME:
4640                 if (line->type != LINE_TREE_FILE) {
4641                         report("Blame only supported for files");
4642                         return REQ_NONE;
4643                 }
4645                 string_copy(opt_ref, view->vid);
4646                 return request;
4648         case REQ_EDIT:
4649                 if (line->type != LINE_TREE_FILE) {
4650                         report("Edit only supported for files");
4651                 } else if (!is_head_commit(view->vid)) {
4652                         open_blob_editor();
4653                 } else {
4654                         open_editor(opt_file);
4655                 }
4656                 return REQ_NONE;
4658         case REQ_TOGGLE_SORT_FIELD:
4659         case REQ_TOGGLE_SORT_ORDER:
4660                 sort_view(view, request, &tree_sort_state, tree_compare);
4661                 return REQ_NONE;
4663         case REQ_PARENT:
4664                 if (!*opt_path) {
4665                         /* quit view if at top of tree */
4666                         return REQ_VIEW_CLOSE;
4667                 }
4668                 /* fake 'cd  ..' */
4669                 line = &view->line[1];
4670                 break;
4672         case REQ_ENTER:
4673                 break;
4675         default:
4676                 return request;
4677         }
4679         /* Cleanup the stack if the tree view is at a different tree. */
4680         while (!*opt_path && tree_stack)
4681                 pop_tree_stack_entry();
4683         switch (line->type) {
4684         case LINE_TREE_DIR:
4685                 /* Depending on whether it is a subdirectory or parent link
4686                  * mangle the path buffer. */
4687                 if (line == &view->line[1] && *opt_path) {
4688                         pop_tree_stack_entry();
4690                 } else {
4691                         const char *basename = tree_path(line);
4693                         push_tree_stack_entry(basename, view->lineno);
4694                 }
4696                 /* Trees and subtrees share the same ID, so they are not not
4697                  * unique like blobs. */
4698                 flags = OPEN_RELOAD;
4699                 request = REQ_VIEW_TREE;
4700                 break;
4702         case LINE_TREE_FILE:
4703                 flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
4704                 request = REQ_VIEW_BLOB;
4705                 break;
4707         default:
4708                 return REQ_NONE;
4709         }
4711         open_view(view, request, flags);
4712         if (request == REQ_VIEW_TREE)
4713                 view->lineno = tree_lineno;
4715         return REQ_NONE;
4718 static bool
4719 tree_grep(struct view *view, struct line *line)
4721         struct tree_entry *entry = line->data;
4722         const char *text[] = {
4723                 entry->name,
4724                 opt_author ? entry->author : "",
4725                 mkdate(&entry->time, opt_date),
4726                 NULL
4727         };
4729         return grep_text(view, text);
4732 static void
4733 tree_select(struct view *view, struct line *line)
4735         struct tree_entry *entry = line->data;
4737         if (line->type == LINE_TREE_FILE) {
4738                 string_copy_rev(ref_blob, entry->id);
4739                 string_format(opt_file, "%s%s", opt_path, tree_path(line));
4741         } else if (line->type != LINE_TREE_DIR) {
4742                 return;
4743         }
4745         string_copy_rev(view->ref, entry->id);
4748 static bool
4749 tree_prepare(struct view *view)
4751         if (view->lines == 0 && opt_prefix[0]) {
4752                 char *pos = opt_prefix;
4754                 while (pos && *pos) {
4755                         char *end = strchr(pos, '/');
4757                         if (end)
4758                                 *end = 0;
4759                         push_tree_stack_entry(pos, 0);
4760                         pos = end;
4761                         if (end) {
4762                                 *end = '/';
4763                                 pos++;
4764                         }
4765                 }
4767         } else if (strcmp(view->vid, view->id)) {
4768                 opt_path[0] = 0;
4769         }
4771         return io_format(&view->io, opt_cdup, IO_RD, view->ops->argv, FORMAT_ALL);
4774 static const char *tree_argv[SIZEOF_ARG] = {
4775         "git", "ls-tree", "%(commit)", "%(directory)", NULL
4776 };
4778 static struct view_ops tree_ops = {
4779         "file",
4780         tree_argv,
4781         NULL,
4782         tree_read,
4783         tree_draw,
4784         tree_request,
4785         tree_grep,
4786         tree_select,
4787         tree_prepare,
4788 };
4790 static bool
4791 blob_read(struct view *view, char *line)
4793         if (!line)
4794                 return TRUE;
4795         return add_line_text(view, line, LINE_DEFAULT) != NULL;
4798 static enum request
4799 blob_request(struct view *view, enum request request, struct line *line)
4801         switch (request) {
4802         case REQ_EDIT:
4803                 open_blob_editor();
4804                 return REQ_NONE;
4805         default:
4806                 return pager_request(view, request, line);
4807         }
4810 static const char *blob_argv[SIZEOF_ARG] = {
4811         "git", "cat-file", "blob", "%(blob)", NULL
4812 };
4814 static struct view_ops blob_ops = {
4815         "line",
4816         blob_argv,
4817         NULL,
4818         blob_read,
4819         pager_draw,
4820         blob_request,
4821         pager_grep,
4822         pager_select,
4823 };
4825 /*
4826  * Blame backend
4827  *
4828  * Loading the blame view is a two phase job:
4829  *
4830  *  1. File content is read either using opt_file from the
4831  *     filesystem or using git-cat-file.
4832  *  2. Then blame information is incrementally added by
4833  *     reading output from git-blame.
4834  */
4836 static const char *blame_head_argv[] = {
4837         "git", "blame", "--incremental", "--", "%(file)", NULL
4838 };
4840 static const char *blame_ref_argv[] = {
4841         "git", "blame", "--incremental", "%(ref)", "--", "%(file)", NULL
4842 };
4844 static const char *blame_cat_file_argv[] = {
4845         "git", "cat-file", "blob", "%(ref):%(file)", NULL
4846 };
4848 struct blame_commit {
4849         char id[SIZEOF_REV];            /* SHA1 ID. */
4850         char title[128];                /* First line of the commit message. */
4851         const char *author;             /* Author of the commit. */
4852         struct time time;               /* Date from the author ident. */
4853         char filename[128];             /* Name of file. */
4854         bool has_previous;              /* Was a "previous" line detected. */
4855 };
4857 struct blame {
4858         struct blame_commit *commit;
4859         unsigned long lineno;
4860         char text[1];
4861 };
4863 static bool
4864 blame_open(struct view *view)
4866         char path[SIZEOF_STR];
4868         if (!view->parent && *opt_prefix) {
4869                 string_copy(path, opt_file);
4870                 if (!string_format(opt_file, "%s%s", opt_prefix, path))
4871                         return FALSE;
4872         }
4874         if (*opt_ref || !io_open(&view->io, "%s%s", opt_cdup, opt_file)) {
4875                 if (!io_run_rd(&view->io, blame_cat_file_argv, opt_cdup, FORMAT_ALL))
4876                         return FALSE;
4877         }
4879         setup_update(view, opt_file);
4880         string_format(view->ref, "%s ...", opt_file);
4882         return TRUE;
4885 static struct blame_commit *
4886 get_blame_commit(struct view *view, const char *id)
4888         size_t i;
4890         for (i = 0; i < view->lines; i++) {
4891                 struct blame *blame = view->line[i].data;
4893                 if (!blame->commit)
4894                         continue;
4896                 if (!strncmp(blame->commit->id, id, SIZEOF_REV - 1))
4897                         return blame->commit;
4898         }
4900         {
4901                 struct blame_commit *commit = calloc(1, sizeof(*commit));
4903                 if (commit)
4904                         string_ncopy(commit->id, id, SIZEOF_REV);
4905                 return commit;
4906         }
4909 static bool
4910 parse_number(const char **posref, size_t *number, size_t min, size_t max)
4912         const char *pos = *posref;
4914         *posref = NULL;
4915         pos = strchr(pos + 1, ' ');
4916         if (!pos || !isdigit(pos[1]))
4917                 return FALSE;
4918         *number = atoi(pos + 1);
4919         if (*number < min || *number > max)
4920                 return FALSE;
4922         *posref = pos;
4923         return TRUE;
4926 static struct blame_commit *
4927 parse_blame_commit(struct view *view, const char *text, int *blamed)
4929         struct blame_commit *commit;
4930         struct blame *blame;
4931         const char *pos = text + SIZEOF_REV - 2;
4932         size_t orig_lineno = 0;
4933         size_t lineno;
4934         size_t group;
4936         if (strlen(text) <= SIZEOF_REV || pos[1] != ' ')
4937                 return NULL;
4939         if (!parse_number(&pos, &orig_lineno, 1, 9999999) ||
4940             !parse_number(&pos, &lineno, 1, view->lines) ||
4941             !parse_number(&pos, &group, 1, view->lines - lineno + 1))
4942                 return NULL;
4944         commit = get_blame_commit(view, text);
4945         if (!commit)
4946                 return NULL;
4948         *blamed += group;
4949         while (group--) {
4950                 struct line *line = &view->line[lineno + group - 1];
4952                 blame = line->data;
4953                 blame->commit = commit;
4954                 blame->lineno = orig_lineno + group - 1;
4955                 line->dirty = 1;
4956         }
4958         return commit;
4961 static bool
4962 blame_read_file(struct view *view, const char *line, bool *read_file)
4964         if (!line) {
4965                 const char **argv = *opt_ref ? blame_ref_argv : blame_head_argv;
4966                 struct io io = {};
4968                 if (view->lines == 0 && !view->parent)
4969                         die("No blame exist for %s", view->vid);
4971                 if (view->lines == 0 || !io_run_rd(&io, argv, opt_cdup, FORMAT_ALL)) {
4972                         report("Failed to load blame data");
4973                         return TRUE;
4974                 }
4976                 io_done(view->pipe);
4977                 view->io = io;
4978                 *read_file = FALSE;
4979                 return FALSE;
4981         } else {
4982                 size_t linelen = strlen(line);
4983                 struct blame *blame = malloc(sizeof(*blame) + linelen);
4985                 if (!blame)
4986                         return FALSE;
4988                 blame->commit = NULL;
4989                 strncpy(blame->text, line, linelen);
4990                 blame->text[linelen] = 0;
4991                 return add_line_data(view, blame, LINE_BLAME_ID) != NULL;
4992         }
4995 static bool
4996 match_blame_header(const char *name, char **line)
4998         size_t namelen = strlen(name);
4999         bool matched = !strncmp(name, *line, namelen);
5001         if (matched)
5002                 *line += namelen;
5004         return matched;
5007 static bool
5008 blame_read(struct view *view, char *line)
5010         static struct blame_commit *commit = NULL;
5011         static int blamed = 0;
5012         static bool read_file = TRUE;
5014         if (read_file)
5015                 return blame_read_file(view, line, &read_file);
5017         if (!line) {
5018                 /* Reset all! */
5019                 commit = NULL;
5020                 blamed = 0;
5021                 read_file = TRUE;
5022                 string_format(view->ref, "%s", view->vid);
5023                 if (view_is_displayed(view)) {
5024                         update_view_title(view);
5025                         redraw_view_from(view, 0);
5026                 }
5027                 return TRUE;
5028         }
5030         if (!commit) {
5031                 commit = parse_blame_commit(view, line, &blamed);
5032                 string_format(view->ref, "%s %2d%%", view->vid,
5033                               view->lines ? blamed * 100 / view->lines : 0);
5035         } else if (match_blame_header("author ", &line)) {
5036                 commit->author = get_author(line);
5038         } else if (match_blame_header("author-time ", &line)) {
5039                 parse_timesec(&commit->time, line);
5041         } else if (match_blame_header("author-tz ", &line)) {
5042                 parse_timezone(&commit->time, line);
5044         } else if (match_blame_header("summary ", &line)) {
5045                 string_ncopy(commit->title, line, strlen(line));
5047         } else if (match_blame_header("previous ", &line)) {
5048                 commit->has_previous = TRUE;
5050         } else if (match_blame_header("filename ", &line)) {
5051                 string_ncopy(commit->filename, line, strlen(line));
5052                 commit = NULL;
5053         }
5055         return TRUE;
5058 static bool
5059 blame_draw(struct view *view, struct line *line, unsigned int lineno)
5061         struct blame *blame = line->data;
5062         struct time *time = NULL;
5063         const char *id = NULL, *author = NULL;
5064         char text[SIZEOF_STR];
5066         if (blame->commit && *blame->commit->filename) {
5067                 id = blame->commit->id;
5068                 author = blame->commit->author;
5069                 time = &blame->commit->time;
5070         }
5072         if (opt_date && draw_date(view, time))
5073                 return TRUE;
5075         if (opt_author && draw_author(view, author))
5076                 return TRUE;
5078         if (draw_field(view, LINE_BLAME_ID, id, ID_COLS, FALSE))
5079                 return TRUE;
5081         if (draw_lineno(view, lineno))
5082                 return TRUE;
5084         string_expand(text, sizeof(text), blame->text, opt_tab_size);
5085         draw_text(view, LINE_DEFAULT, text, TRUE);
5086         return TRUE;
5089 static bool
5090 check_blame_commit(struct blame *blame, bool check_null_id)
5092         if (!blame->commit)
5093                 report("Commit data not loaded yet");
5094         else if (check_null_id && !strcmp(blame->commit->id, NULL_ID))
5095                 report("No commit exist for the selected line");
5096         else
5097                 return TRUE;
5098         return FALSE;
5101 static void
5102 setup_blame_parent_line(struct view *view, struct blame *blame)
5104         const char *diff_tree_argv[] = {
5105                 "git", "diff-tree", "-U0", blame->commit->id,
5106                         "--", blame->commit->filename, NULL
5107         };
5108         struct io io = {};
5109         int parent_lineno = -1;
5110         int blamed_lineno = -1;
5111         char *line;
5113         if (!io_run(&io, diff_tree_argv, NULL, IO_RD))
5114                 return;
5116         while ((line = io_get(&io, '\n', TRUE))) {
5117                 if (*line == '@') {
5118                         char *pos = strchr(line, '+');
5120                         parent_lineno = atoi(line + 4);
5121                         if (pos)
5122                                 blamed_lineno = atoi(pos + 1);
5124                 } else if (*line == '+' && parent_lineno != -1) {
5125                         if (blame->lineno == blamed_lineno - 1 &&
5126                             !strcmp(blame->text, line + 1)) {
5127                                 view->lineno = parent_lineno ? parent_lineno - 1 : 0;
5128                                 break;
5129                         }
5130                         blamed_lineno++;
5131                 }
5132         }
5134         io_done(&io);
5137 static enum request
5138 blame_request(struct view *view, enum request request, struct line *line)
5140         enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
5141         struct blame *blame = line->data;
5143         switch (request) {
5144         case REQ_VIEW_BLAME:
5145                 if (check_blame_commit(blame, TRUE)) {
5146                         string_copy(opt_ref, blame->commit->id);
5147                         string_copy(opt_file, blame->commit->filename);
5148                         if (blame->lineno)
5149                                 view->lineno = blame->lineno;
5150                         open_view(view, REQ_VIEW_BLAME, OPEN_REFRESH);
5151                 }
5152                 break;
5154         case REQ_PARENT:
5155                 if (check_blame_commit(blame, TRUE) &&
5156                     select_commit_parent(blame->commit->id, opt_ref,
5157                                          blame->commit->filename)) {
5158                         string_copy(opt_file, blame->commit->filename);
5159                         setup_blame_parent_line(view, blame);
5160                         open_view(view, REQ_VIEW_BLAME, OPEN_REFRESH);
5161                 }
5162                 break;
5164         case REQ_ENTER:
5165                 if (!check_blame_commit(blame, FALSE))
5166                         break;
5168                 if (view_is_displayed(VIEW(REQ_VIEW_DIFF)) &&
5169                     !strcmp(blame->commit->id, VIEW(REQ_VIEW_DIFF)->ref))
5170                         break;
5172                 if (!strcmp(blame->commit->id, NULL_ID)) {
5173                         struct view *diff = VIEW(REQ_VIEW_DIFF);
5174                         const char *diff_index_argv[] = {
5175                                 "git", "diff-index", "--root", "--patch-with-stat",
5176                                         "-C", "-M", "HEAD", "--", view->vid, NULL
5177                         };
5179                         if (!blame->commit->has_previous) {
5180                                 diff_index_argv[1] = "diff";
5181                                 diff_index_argv[2] = "--no-color";
5182                                 diff_index_argv[6] = "--";
5183                                 diff_index_argv[7] = "/dev/null";
5184                         }
5186                         if (!prepare_update(diff, diff_index_argv, NULL)) {
5187                                 report("Failed to allocate diff command");
5188                                 break;
5189                         }
5190                         flags |= OPEN_PREPARED;
5191                 }
5193                 open_view(view, REQ_VIEW_DIFF, flags);
5194                 if (VIEW(REQ_VIEW_DIFF)->pipe && !strcmp(blame->commit->id, NULL_ID))
5195                         string_copy_rev(VIEW(REQ_VIEW_DIFF)->ref, NULL_ID);
5196                 break;
5198         default:
5199                 return request;
5200         }
5202         return REQ_NONE;
5205 static bool
5206 blame_grep(struct view *view, struct line *line)
5208         struct blame *blame = line->data;
5209         struct blame_commit *commit = blame->commit;
5210         const char *text[] = {
5211                 blame->text,
5212                 commit ? commit->title : "",
5213                 commit ? commit->id : "",
5214                 commit && opt_author ? commit->author : "",
5215                 commit ? mkdate(&commit->time, opt_date) : "",
5216                 NULL
5217         };
5219         return grep_text(view, text);
5222 static void
5223 blame_select(struct view *view, struct line *line)
5225         struct blame *blame = line->data;
5226         struct blame_commit *commit = blame->commit;
5228         if (!commit)
5229                 return;
5231         if (!strcmp(commit->id, NULL_ID))
5232                 string_ncopy(ref_commit, "HEAD", 4);
5233         else
5234                 string_copy_rev(ref_commit, commit->id);
5237 static struct view_ops blame_ops = {
5238         "line",
5239         NULL,
5240         blame_open,
5241         blame_read,
5242         blame_draw,
5243         blame_request,
5244         blame_grep,
5245         blame_select,
5246 };
5248 /*
5249  * Branch backend
5250  */
5252 struct branch {
5253         const char *author;             /* Author of the last commit. */
5254         struct time time;               /* Date of the last activity. */
5255         const struct ref *ref;          /* Name and commit ID information. */
5256 };
5258 static const struct ref branch_all;
5260 static const enum sort_field branch_sort_fields[] = {
5261         ORDERBY_NAME, ORDERBY_DATE, ORDERBY_AUTHOR
5262 };
5263 static struct sort_state branch_sort_state = SORT_STATE(branch_sort_fields);
5265 static int
5266 branch_compare(const void *l1, const void *l2)
5268         const struct branch *branch1 = ((const struct line *) l1)->data;
5269         const struct branch *branch2 = ((const struct line *) l2)->data;
5271         switch (get_sort_field(branch_sort_state)) {
5272         case ORDERBY_DATE:
5273                 return sort_order(branch_sort_state, timecmp(&branch1->time, &branch2->time));
5275         case ORDERBY_AUTHOR:
5276                 return sort_order(branch_sort_state, strcmp(branch1->author, branch2->author));
5278         case ORDERBY_NAME:
5279         default:
5280                 return sort_order(branch_sort_state, strcmp(branch1->ref->name, branch2->ref->name));
5281         }
5284 static bool
5285 branch_draw(struct view *view, struct line *line, unsigned int lineno)
5287         struct branch *branch = line->data;
5288         enum line_type type = branch->ref->head ? LINE_MAIN_HEAD : LINE_DEFAULT;
5290         if (opt_date && draw_date(view, &branch->time))
5291                 return TRUE;
5293         if (opt_author && draw_author(view, branch->author))
5294                 return TRUE;
5296         draw_text(view, type, branch->ref == &branch_all ? "All branches" : branch->ref->name, TRUE);
5297         return TRUE;
5300 static enum request
5301 branch_request(struct view *view, enum request request, struct line *line)
5303         struct branch *branch = line->data;
5305         switch (request) {
5306         case REQ_REFRESH:
5307                 load_refs();
5308                 open_view(view, REQ_VIEW_BRANCH, OPEN_REFRESH);
5309                 return REQ_NONE;
5311         case REQ_TOGGLE_SORT_FIELD:
5312         case REQ_TOGGLE_SORT_ORDER:
5313                 sort_view(view, request, &branch_sort_state, branch_compare);
5314                 return REQ_NONE;
5316         case REQ_ENTER:
5317                 if (branch->ref == &branch_all) {
5318                         const char *all_branches_argv[] = {
5319                                 "git", "log", "--no-color", "--pretty=raw", "--parents",
5320                                       "--topo-order", "--all", NULL
5321                         };
5322                         struct view *main_view = VIEW(REQ_VIEW_MAIN);
5324                         if (!prepare_update(main_view, all_branches_argv, NULL)) {
5325                                 report("Failed to load view of all branches");
5326                                 return REQ_NONE;
5327                         }
5328                         open_view(view, REQ_VIEW_MAIN, OPEN_PREPARED | OPEN_SPLIT);
5329                 } else {
5330                         open_view(view, REQ_VIEW_MAIN, OPEN_SPLIT);
5331                 }
5332                 return REQ_NONE;
5334         default:
5335                 return request;
5336         }
5339 static bool
5340 branch_read(struct view *view, char *line)
5342         static char id[SIZEOF_REV];
5343         struct branch *reference;
5344         size_t i;
5346         if (!line)
5347                 return TRUE;
5349         switch (get_line_type(line)) {
5350         case LINE_COMMIT:
5351                 string_copy_rev(id, line + STRING_SIZE("commit "));
5352                 return TRUE;
5354         case LINE_AUTHOR:
5355                 for (i = 0, reference = NULL; i < view->lines; i++) {
5356                         struct branch *branch = view->line[i].data;
5358                         if (strcmp(branch->ref->id, id))
5359                                 continue;
5361                         view->line[i].dirty = TRUE;
5362                         if (reference) {
5363                                 branch->author = reference->author;
5364                                 branch->time = reference->time;
5365                                 continue;
5366                         }
5368                         parse_author_line(line + STRING_SIZE("author "),
5369                                           &branch->author, &branch->time);
5370                         reference = branch;
5371                 }
5372                 return TRUE;
5374         default:
5375                 return TRUE;
5376         }
5380 static bool
5381 branch_open_visitor(void *data, const struct ref *ref)
5383         struct view *view = data;
5384         struct branch *branch;
5386         if (ref->tag || ref->ltag || ref->remote)
5387                 return TRUE;
5389         branch = calloc(1, sizeof(*branch));
5390         if (!branch)
5391                 return FALSE;
5393         branch->ref = ref;
5394         return !!add_line_data(view, branch, LINE_DEFAULT);
5397 static bool
5398 branch_open(struct view *view)
5400         const char *branch_log[] = {
5401                 "git", "log", "--no-color", "--pretty=raw",
5402                         "--simplify-by-decoration", "--all", NULL
5403         };
5405         if (!io_run_rd(&view->io, branch_log, NULL, FORMAT_NONE)) {
5406                 report("Failed to load branch data");
5407                 return TRUE;
5408         }
5410         setup_update(view, view->id);
5411         branch_open_visitor(view, &branch_all);
5412         foreach_ref(branch_open_visitor, view);
5413         view->p_restore = TRUE;
5415         return TRUE;
5418 static bool
5419 branch_grep(struct view *view, struct line *line)
5421         struct branch *branch = line->data;
5422         const char *text[] = {
5423                 branch->ref->name,
5424                 branch->author,
5425                 NULL
5426         };
5428         return grep_text(view, text);
5431 static void
5432 branch_select(struct view *view, struct line *line)
5434         struct branch *branch = line->data;
5436         string_copy_rev(view->ref, branch->ref->id);
5437         string_copy_rev(ref_commit, branch->ref->id);
5438         string_copy_rev(ref_head, branch->ref->id);
5439         string_copy_rev(ref_branch, branch->ref->name);
5442 static struct view_ops branch_ops = {
5443         "branch",
5444         NULL,
5445         branch_open,
5446         branch_read,
5447         branch_draw,
5448         branch_request,
5449         branch_grep,
5450         branch_select,
5451 };
5453 /*
5454  * Status backend
5455  */
5457 struct status {
5458         char status;
5459         struct {
5460                 mode_t mode;
5461                 char rev[SIZEOF_REV];
5462                 char name[SIZEOF_STR];
5463         } old;
5464         struct {
5465                 mode_t mode;
5466                 char rev[SIZEOF_REV];
5467                 char name[SIZEOF_STR];
5468         } new;
5469 };
5471 static char status_onbranch[SIZEOF_STR];
5472 static struct status stage_status;
5473 static enum line_type stage_line_type;
5474 static size_t stage_chunks;
5475 static int *stage_chunk;
5477 DEFINE_ALLOCATOR(realloc_ints, int, 32)
5479 /* This should work even for the "On branch" line. */
5480 static inline bool
5481 status_has_none(struct view *view, struct line *line)
5483         return line < view->line + view->lines && !line[1].data;
5486 /* Get fields from the diff line:
5487  * :100644 100644 06a5d6ae9eca55be2e0e585a152e6b1336f2b20e 0000000000000000000000000000000000000000 M
5488  */
5489 static inline bool
5490 status_get_diff(struct status *file, const char *buf, size_t bufsize)
5492         const char *old_mode = buf +  1;
5493         const char *new_mode = buf +  8;
5494         const char *old_rev  = buf + 15;
5495         const char *new_rev  = buf + 56;
5496         const char *status   = buf + 97;
5498         if (bufsize < 98 ||
5499             old_mode[-1] != ':' ||
5500             new_mode[-1] != ' ' ||
5501             old_rev[-1]  != ' ' ||
5502             new_rev[-1]  != ' ' ||
5503             status[-1]   != ' ')
5504                 return FALSE;
5506         file->status = *status;
5508         string_copy_rev(file->old.rev, old_rev);
5509         string_copy_rev(file->new.rev, new_rev);
5511         file->old.mode = strtoul(old_mode, NULL, 8);
5512         file->new.mode = strtoul(new_mode, NULL, 8);
5514         file->old.name[0] = file->new.name[0] = 0;
5516         return TRUE;
5519 static bool
5520 status_run(struct view *view, const char *argv[], char status, enum line_type type)
5522         struct status *unmerged = NULL;
5523         char *buf;
5524         struct io io = {};
5526         if (!io_run(&io, argv, opt_cdup, IO_RD))
5527                 return FALSE;
5529         add_line_data(view, NULL, type);
5531         while ((buf = io_get(&io, 0, TRUE))) {
5532                 struct status *file = unmerged;
5534                 if (!file) {
5535                         file = calloc(1, sizeof(*file));
5536                         if (!file || !add_line_data(view, file, type))
5537                                 goto error_out;
5538                 }
5540                 /* Parse diff info part. */
5541                 if (status) {
5542                         file->status = status;
5543                         if (status == 'A')
5544                                 string_copy(file->old.rev, NULL_ID);
5546                 } else if (!file->status || file == unmerged) {
5547                         if (!status_get_diff(file, buf, strlen(buf)))
5548                                 goto error_out;
5550                         buf = io_get(&io, 0, TRUE);
5551                         if (!buf)
5552                                 break;
5554                         /* Collapse all modified entries that follow an
5555                          * associated unmerged entry. */
5556                         if (unmerged == file) {
5557                                 unmerged->status = 'U';
5558                                 unmerged = NULL;
5559                         } else if (file->status == 'U') {
5560                                 unmerged = file;
5561                         }
5562                 }
5564                 /* Grab the old name for rename/copy. */
5565                 if (!*file->old.name &&
5566                     (file->status == 'R' || file->status == 'C')) {
5567                         string_ncopy(file->old.name, buf, strlen(buf));
5569                         buf = io_get(&io, 0, TRUE);
5570                         if (!buf)
5571                                 break;
5572                 }
5574                 /* git-ls-files just delivers a NUL separated list of
5575                  * file names similar to the second half of the
5576                  * git-diff-* output. */
5577                 string_ncopy(file->new.name, buf, strlen(buf));
5578                 if (!*file->old.name)
5579                         string_copy(file->old.name, file->new.name);
5580                 file = NULL;
5581         }
5583         if (io_error(&io)) {
5584 error_out:
5585                 io_done(&io);
5586                 return FALSE;
5587         }
5589         if (!view->line[view->lines - 1].data)
5590                 add_line_data(view, NULL, LINE_STAT_NONE);
5592         io_done(&io);
5593         return TRUE;
5596 /* Don't show unmerged entries in the staged section. */
5597 static const char *status_diff_index_argv[] = {
5598         "git", "diff-index", "-z", "--diff-filter=ACDMRTXB",
5599                              "--cached", "-M", "HEAD", NULL
5600 };
5602 static const char *status_diff_files_argv[] = {
5603         "git", "diff-files", "-z", NULL
5604 };
5606 static const char *status_list_other_argv[] = {
5607         "git", "ls-files", "-z", "--others", "--exclude-standard", opt_prefix, NULL
5608 };
5610 static const char *status_list_no_head_argv[] = {
5611         "git", "ls-files", "-z", "--cached", "--exclude-standard", NULL
5612 };
5614 static const char *update_index_argv[] = {
5615         "git", "update-index", "-q", "--unmerged", "--refresh", NULL
5616 };
5618 /* Restore the previous line number to stay in the context or select a
5619  * line with something that can be updated. */
5620 static void
5621 status_restore(struct view *view)
5623         if (view->p_lineno >= view->lines)
5624                 view->p_lineno = view->lines - 1;
5625         while (view->p_lineno < view->lines && !view->line[view->p_lineno].data)
5626                 view->p_lineno++;
5627         while (view->p_lineno > 0 && !view->line[view->p_lineno].data)
5628                 view->p_lineno--;
5630         /* If the above fails, always skip the "On branch" line. */
5631         if (view->p_lineno < view->lines)
5632                 view->lineno = view->p_lineno;
5633         else
5634                 view->lineno = 1;
5636         if (view->lineno < view->offset)
5637                 view->offset = view->lineno;
5638         else if (view->offset + view->height <= view->lineno)
5639                 view->offset = view->lineno - view->height + 1;
5641         view->p_restore = FALSE;
5644 static void
5645 status_update_onbranch(void)
5647         static const char *paths[][2] = {
5648                 { "rebase-apply/rebasing",      "Rebasing" },
5649                 { "rebase-apply/applying",      "Applying mailbox" },
5650                 { "rebase-apply/",              "Rebasing mailbox" },
5651                 { "rebase-merge/interactive",   "Interactive rebase" },
5652                 { "rebase-merge/",              "Rebase merge" },
5653                 { "MERGE_HEAD",                 "Merging" },
5654                 { "BISECT_LOG",                 "Bisecting" },
5655                 { "HEAD",                       "On branch" },
5656         };
5657         char buf[SIZEOF_STR];
5658         struct stat stat;
5659         int i;
5661         if (is_initial_commit()) {
5662                 string_copy(status_onbranch, "Initial commit");
5663                 return;
5664         }
5666         for (i = 0; i < ARRAY_SIZE(paths); i++) {
5667                 char *head = opt_head;
5669                 if (!string_format(buf, "%s/%s", opt_git_dir, paths[i][0]) ||
5670                     lstat(buf, &stat) < 0)
5671                         continue;
5673                 if (!*opt_head) {
5674                         struct io io = {};
5676                         if (io_open(&io, "%s/rebase-merge/head-name", opt_git_dir) &&
5677                             io_read_buf(&io, buf, sizeof(buf))) {
5678                                 head = buf;
5679                                 if (!prefixcmp(head, "refs/heads/"))
5680                                         head += STRING_SIZE("refs/heads/");
5681                         }
5682                 }
5684                 if (!string_format(status_onbranch, "%s %s", paths[i][1], head))
5685                         string_copy(status_onbranch, opt_head);
5686                 return;
5687         }
5689         string_copy(status_onbranch, "Not currently on any branch");
5692 /* First parse staged info using git-diff-index(1), then parse unstaged
5693  * info using git-diff-files(1), and finally untracked files using
5694  * git-ls-files(1). */
5695 static bool
5696 status_open(struct view *view)
5698         reset_view(view);
5700         add_line_data(view, NULL, LINE_STAT_HEAD);
5701         status_update_onbranch();
5703         io_run_bg(update_index_argv);
5705         if (is_initial_commit()) {
5706                 if (!status_run(view, status_list_no_head_argv, 'A', LINE_STAT_STAGED))
5707                         return FALSE;
5708         } else if (!status_run(view, status_diff_index_argv, 0, LINE_STAT_STAGED)) {
5709                 return FALSE;
5710         }
5712         if (!status_run(view, status_diff_files_argv, 0, LINE_STAT_UNSTAGED) ||
5713             !status_run(view, status_list_other_argv, '?', LINE_STAT_UNTRACKED))
5714                 return FALSE;
5716         /* Restore the exact position or use the specialized restore
5717          * mode? */
5718         if (!view->p_restore)
5719                 status_restore(view);
5720         return TRUE;
5723 static bool
5724 status_draw(struct view *view, struct line *line, unsigned int lineno)
5726         struct status *status = line->data;
5727         enum line_type type;
5728         const char *text;
5730         if (!status) {
5731                 switch (line->type) {
5732                 case LINE_STAT_STAGED:
5733                         type = LINE_STAT_SECTION;
5734                         text = "Changes to be committed:";
5735                         break;
5737                 case LINE_STAT_UNSTAGED:
5738                         type = LINE_STAT_SECTION;
5739                         text = "Changed but not updated:";
5740                         break;
5742                 case LINE_STAT_UNTRACKED:
5743                         type = LINE_STAT_SECTION;
5744                         text = "Untracked files:";
5745                         break;
5747                 case LINE_STAT_NONE:
5748                         type = LINE_DEFAULT;
5749                         text = "  (no files)";
5750                         break;
5752                 case LINE_STAT_HEAD:
5753                         type = LINE_STAT_HEAD;
5754                         text = status_onbranch;
5755                         break;
5757                 default:
5758                         return FALSE;
5759                 }
5760         } else {
5761                 static char buf[] = { '?', ' ', ' ', ' ', 0 };
5763                 buf[0] = status->status;
5764                 if (draw_text(view, line->type, buf, TRUE))
5765                         return TRUE;
5766                 type = LINE_DEFAULT;
5767                 text = status->new.name;
5768         }
5770         draw_text(view, type, text, TRUE);
5771         return TRUE;
5774 static enum request
5775 status_load_error(struct view *view, struct view *stage, const char *path)
5777         if (displayed_views() == 2 || display[current_view] != view)
5778                 maximize_view(view);
5779         report("Failed to load '%s': %s", path, io_strerror(&stage->io));
5780         return REQ_NONE;
5783 static enum request
5784 status_enter(struct view *view, struct line *line)
5786         struct status *status = line->data;
5787         const char *oldpath = status ? status->old.name : NULL;
5788         /* Diffs for unmerged entries are empty when passing the new
5789          * path, so leave it empty. */
5790         const char *newpath = status && status->status != 'U' ? status->new.name : NULL;
5791         const char *info;
5792         enum open_flags split;
5793         struct view *stage = VIEW(REQ_VIEW_STAGE);
5795         if (line->type == LINE_STAT_NONE ||
5796             (!status && line[1].type == LINE_STAT_NONE)) {
5797                 report("No file to diff");
5798                 return REQ_NONE;
5799         }
5801         switch (line->type) {
5802         case LINE_STAT_STAGED:
5803                 if (is_initial_commit()) {
5804                         const char *no_head_diff_argv[] = {
5805                                 "git", "diff", "--no-color", "--patch-with-stat",
5806                                         "--", "/dev/null", newpath, NULL
5807                         };
5809                         if (!prepare_update(stage, no_head_diff_argv, opt_cdup))
5810                                 return status_load_error(view, stage, newpath);
5811                 } else {
5812                         const char *index_show_argv[] = {
5813                                 "git", "diff-index", "--root", "--patch-with-stat",
5814                                         "-C", "-M", "--cached", "HEAD", "--",
5815                                         oldpath, newpath, NULL
5816                         };
5818                         if (!prepare_update(stage, index_show_argv, opt_cdup))
5819                                 return status_load_error(view, stage, newpath);
5820                 }
5822                 if (status)
5823                         info = "Staged changes to %s";
5824                 else
5825                         info = "Staged changes";
5826                 break;
5828         case LINE_STAT_UNSTAGED:
5829         {
5830                 const char *files_show_argv[] = {
5831                         "git", "diff-files", "--root", "--patch-with-stat",
5832                                 "-C", "-M", "--", oldpath, newpath, NULL
5833                 };
5835                 if (!prepare_update(stage, files_show_argv, opt_cdup))
5836                         return status_load_error(view, stage, newpath);
5837                 if (status)
5838                         info = "Unstaged changes to %s";
5839                 else
5840                         info = "Unstaged changes";
5841                 break;
5842         }
5843         case LINE_STAT_UNTRACKED:
5844                 if (!newpath) {
5845                         report("No file to show");
5846                         return REQ_NONE;
5847                 }
5849                 if (!suffixcmp(status->new.name, -1, "/")) {
5850                         report("Cannot display a directory");
5851                         return REQ_NONE;
5852                 }
5854                 if (!prepare_update_file(stage, newpath))
5855                         return status_load_error(view, stage, newpath);
5856                 info = "Untracked file %s";
5857                 break;
5859         case LINE_STAT_HEAD:
5860                 return REQ_NONE;
5862         default:
5863                 die("line type %d not handled in switch", line->type);
5864         }
5866         split = view_is_displayed(view) ? OPEN_SPLIT : 0;
5867         open_view(view, REQ_VIEW_STAGE, OPEN_PREPARED | split);
5868         if (view_is_displayed(VIEW(REQ_VIEW_STAGE))) {
5869                 if (status) {
5870                         stage_status = *status;
5871                 } else {
5872                         memset(&stage_status, 0, sizeof(stage_status));
5873                 }
5875                 stage_line_type = line->type;
5876                 stage_chunks = 0;
5877                 string_format(VIEW(REQ_VIEW_STAGE)->ref, info, stage_status.new.name);
5878         }
5880         return REQ_NONE;
5883 static bool
5884 status_exists(struct status *status, enum line_type type)
5886         struct view *view = VIEW(REQ_VIEW_STATUS);
5887         unsigned long lineno;
5889         for (lineno = 0; lineno < view->lines; lineno++) {
5890                 struct line *line = &view->line[lineno];
5891                 struct status *pos = line->data;
5893                 if (line->type != type)
5894                         continue;
5895                 if (!pos && (!status || !status->status) && line[1].data) {
5896                         select_view_line(view, lineno);
5897                         return TRUE;
5898                 }
5899                 if (pos && !strcmp(status->new.name, pos->new.name)) {
5900                         select_view_line(view, lineno);
5901                         return TRUE;
5902                 }
5903         }
5905         return FALSE;
5909 static bool
5910 status_update_prepare(struct io *io, enum line_type type)
5912         const char *staged_argv[] = {
5913                 "git", "update-index", "-z", "--index-info", NULL
5914         };
5915         const char *others_argv[] = {
5916                 "git", "update-index", "-z", "--add", "--remove", "--stdin", NULL
5917         };
5919         switch (type) {
5920         case LINE_STAT_STAGED:
5921                 return io_run(io, staged_argv, opt_cdup, IO_WR);
5923         case LINE_STAT_UNSTAGED:
5924         case LINE_STAT_UNTRACKED:
5925                 return io_run(io, others_argv, opt_cdup, IO_WR);
5927         default:
5928                 die("line type %d not handled in switch", type);
5929                 return FALSE;
5930         }
5933 static bool
5934 status_update_write(struct io *io, struct status *status, enum line_type type)
5936         char buf[SIZEOF_STR];
5937         size_t bufsize = 0;
5939         switch (type) {
5940         case LINE_STAT_STAGED:
5941                 if (!string_format_from(buf, &bufsize, "%06o %s\t%s%c",
5942                                         status->old.mode,
5943                                         status->old.rev,
5944                                         status->old.name, 0))
5945                         return FALSE;
5946                 break;
5948         case LINE_STAT_UNSTAGED:
5949         case LINE_STAT_UNTRACKED:
5950                 if (!string_format_from(buf, &bufsize, "%s%c", status->new.name, 0))
5951                         return FALSE;
5952                 break;
5954         default:
5955                 die("line type %d not handled in switch", type);
5956         }
5958         return io_write(io, buf, bufsize);
5961 static bool
5962 status_update_file(struct status *status, enum line_type type)
5964         struct io io = {};
5965         bool result;
5967         if (!status_update_prepare(&io, type))
5968                 return FALSE;
5970         result = status_update_write(&io, status, type);
5971         return io_done(&io) && result;
5974 static bool
5975 status_update_files(struct view *view, struct line *line)
5977         char buf[sizeof(view->ref)];
5978         struct io io = {};
5979         bool result = TRUE;
5980         struct line *pos = view->line + view->lines;
5981         int files = 0;
5982         int file, done;
5983         int cursor_y = -1, cursor_x = -1;
5985         if (!status_update_prepare(&io, line->type))
5986                 return FALSE;
5988         for (pos = line; pos < view->line + view->lines && pos->data; pos++)
5989                 files++;
5991         string_copy(buf, view->ref);
5992         getsyx(cursor_y, cursor_x);
5993         for (file = 0, done = 5; result && file < files; line++, file++) {
5994                 int almost_done = file * 100 / files;
5996                 if (almost_done > done) {
5997                         done = almost_done;
5998                         string_format(view->ref, "updating file %u of %u (%d%% done)",
5999                                       file, files, done);
6000                         update_view_title(view);
6001                         setsyx(cursor_y, cursor_x);
6002                         doupdate();
6003                 }
6004                 result = status_update_write(&io, line->data, line->type);
6005         }
6006         string_copy(view->ref, buf);
6008         return io_done(&io) && result;
6011 static bool
6012 status_update(struct view *view)
6014         struct line *line = &view->line[view->lineno];
6016         assert(view->lines);
6018         if (!line->data) {
6019                 /* This should work even for the "On branch" line. */
6020                 if (line < view->line + view->lines && !line[1].data) {
6021                         report("Nothing to update");
6022                         return FALSE;
6023                 }
6025                 if (!status_update_files(view, line + 1)) {
6026                         report("Failed to update file status");
6027                         return FALSE;
6028                 }
6030         } else if (!status_update_file(line->data, line->type)) {
6031                 report("Failed to update file status");
6032                 return FALSE;
6033         }
6035         return TRUE;
6038 static bool
6039 status_revert(struct status *status, enum line_type type, bool has_none)
6041         if (!status || type != LINE_STAT_UNSTAGED) {
6042                 if (type == LINE_STAT_STAGED) {
6043                         report("Cannot revert changes to staged files");
6044                 } else if (type == LINE_STAT_UNTRACKED) {
6045                         report("Cannot revert changes to untracked files");
6046                 } else if (has_none) {
6047                         report("Nothing to revert");
6048                 } else {
6049                         report("Cannot revert changes to multiple files");
6050                 }
6052         } else if (prompt_yesno("Are you sure you want to revert changes?")) {
6053                 char mode[10] = "100644";
6054                 const char *reset_argv[] = {
6055                         "git", "update-index", "--cacheinfo", mode,
6056                                 status->old.rev, status->old.name, NULL
6057                 };
6058                 const char *checkout_argv[] = {
6059                         "git", "checkout", "--", status->old.name, NULL
6060                 };
6062                 if (status->status == 'U') {
6063                         string_format(mode, "%5o", status->old.mode);
6065                         if (status->old.mode == 0 && status->new.mode == 0) {
6066                                 reset_argv[2] = "--force-remove";
6067                                 reset_argv[3] = status->old.name;
6068                                 reset_argv[4] = NULL;
6069                         }
6071                         if (!io_run_fg(reset_argv, opt_cdup))
6072                                 return FALSE;
6073                         if (status->old.mode == 0 && status->new.mode == 0)
6074                                 return TRUE;
6075                 }
6077                 return io_run_fg(checkout_argv, opt_cdup);
6078         }
6080         return FALSE;
6083 static enum request
6084 status_request(struct view *view, enum request request, struct line *line)
6086         struct status *status = line->data;
6088         switch (request) {
6089         case REQ_STATUS_UPDATE:
6090                 if (!status_update(view))
6091                         return REQ_NONE;
6092                 break;
6094         case REQ_STATUS_REVERT:
6095                 if (!status_revert(status, line->type, status_has_none(view, line)))
6096                         return REQ_NONE;
6097                 break;
6099         case REQ_STATUS_MERGE:
6100                 if (!status || status->status != 'U') {
6101                         report("Merging only possible for files with unmerged status ('U').");
6102                         return REQ_NONE;
6103                 }
6104                 open_mergetool(status->new.name);
6105                 break;
6107         case REQ_EDIT:
6108                 if (!status)
6109                         return request;
6110                 if (status->status == 'D') {
6111                         report("File has been deleted.");
6112                         return REQ_NONE;
6113                 }
6115                 open_editor(status->new.name);
6116                 break;
6118         case REQ_VIEW_BLAME:
6119                 if (status)
6120                         opt_ref[0] = 0;
6121                 return request;
6123         case REQ_ENTER:
6124                 /* After returning the status view has been split to
6125                  * show the stage view. No further reloading is
6126                  * necessary. */
6127                 return status_enter(view, line);
6129         case REQ_REFRESH:
6130                 /* Simply reload the view. */
6131                 break;
6133         default:
6134                 return request;
6135         }
6137         open_view(view, REQ_VIEW_STATUS, OPEN_RELOAD);
6139         return REQ_NONE;
6142 static void
6143 status_select(struct view *view, struct line *line)
6145         struct status *status = line->data;
6146         char file[SIZEOF_STR] = "all files";
6147         const char *text;
6148         const char *key;
6150         if (status && !string_format(file, "'%s'", status->new.name))
6151                 return;
6153         if (!status && line[1].type == LINE_STAT_NONE)
6154                 line++;
6156         switch (line->type) {
6157         case LINE_STAT_STAGED:
6158                 text = "Press %s to unstage %s for commit";
6159                 break;
6161         case LINE_STAT_UNSTAGED:
6162                 text = "Press %s to stage %s for commit";
6163                 break;
6165         case LINE_STAT_UNTRACKED:
6166                 text = "Press %s to stage %s for addition";
6167                 break;
6169         case LINE_STAT_HEAD:
6170         case LINE_STAT_NONE:
6171                 text = "Nothing to update";
6172                 break;
6174         default:
6175                 die("line type %d not handled in switch", line->type);
6176         }
6178         if (status && status->status == 'U') {
6179                 text = "Press %s to resolve conflict in %s";
6180                 key = get_key(KEYMAP_STATUS, REQ_STATUS_MERGE);
6182         } else {
6183                 key = get_key(KEYMAP_STATUS, REQ_STATUS_UPDATE);
6184         }
6186         string_format(view->ref, text, key, file);
6187         if (status)
6188                 string_copy(opt_file, status->new.name);
6191 static bool
6192 status_grep(struct view *view, struct line *line)
6194         struct status *status = line->data;
6196         if (status) {
6197                 const char buf[2] = { status->status, 0 };
6198                 const char *text[] = { status->new.name, buf, NULL };
6200                 return grep_text(view, text);
6201         }
6203         return FALSE;
6206 static struct view_ops status_ops = {
6207         "file",
6208         NULL,
6209         status_open,
6210         NULL,
6211         status_draw,
6212         status_request,
6213         status_grep,
6214         status_select,
6215 };
6218 static bool
6219 stage_diff_write(struct io *io, struct line *line, struct line *end)
6221         while (line < end) {
6222                 if (!io_write(io, line->data, strlen(line->data)) ||
6223                     !io_write(io, "\n", 1))
6224                         return FALSE;
6225                 line++;
6226                 if (line->type == LINE_DIFF_CHUNK ||
6227                     line->type == LINE_DIFF_HEADER)
6228                         break;
6229         }
6231         return TRUE;
6234 static struct line *
6235 stage_diff_find(struct view *view, struct line *line, enum line_type type)
6237         for (; view->line < line; line--)
6238                 if (line->type == type)
6239                         return line;
6241         return NULL;
6244 static bool
6245 stage_apply_chunk(struct view *view, struct line *chunk, bool revert)
6247         const char *apply_argv[SIZEOF_ARG] = {
6248                 "git", "apply", "--whitespace=nowarn", NULL
6249         };
6250         struct line *diff_hdr;
6251         struct io io = {};
6252         int argc = 3;
6254         diff_hdr = stage_diff_find(view, chunk, LINE_DIFF_HEADER);
6255         if (!diff_hdr)
6256                 return FALSE;
6258         if (!revert)
6259                 apply_argv[argc++] = "--cached";
6260         if (revert || stage_line_type == LINE_STAT_STAGED)
6261                 apply_argv[argc++] = "-R";
6262         apply_argv[argc++] = "-";
6263         apply_argv[argc++] = NULL;
6264         if (!io_run(&io, apply_argv, opt_cdup, IO_WR))
6265                 return FALSE;
6267         if (!stage_diff_write(&io, diff_hdr, chunk) ||
6268             !stage_diff_write(&io, chunk, view->line + view->lines))
6269                 chunk = NULL;
6271         io_done(&io);
6272         io_run_bg(update_index_argv);
6274         return chunk ? TRUE : FALSE;
6277 static bool
6278 stage_update(struct view *view, struct line *line)
6280         struct line *chunk = NULL;
6282         if (!is_initial_commit() && stage_line_type != LINE_STAT_UNTRACKED)
6283                 chunk = stage_diff_find(view, line, LINE_DIFF_CHUNK);
6285         if (chunk) {
6286                 if (!stage_apply_chunk(view, chunk, FALSE)) {
6287                         report("Failed to apply chunk");
6288                         return FALSE;
6289                 }
6291         } else if (!stage_status.status) {
6292                 view = VIEW(REQ_VIEW_STATUS);
6294                 for (line = view->line; line < view->line + view->lines; line++)
6295                         if (line->type == stage_line_type)
6296                                 break;
6298                 if (!status_update_files(view, line + 1)) {
6299                         report("Failed to update files");
6300                         return FALSE;
6301                 }
6303         } else if (!status_update_file(&stage_status, stage_line_type)) {
6304                 report("Failed to update file");
6305                 return FALSE;
6306         }
6308         return TRUE;
6311 static bool
6312 stage_revert(struct view *view, struct line *line)
6314         struct line *chunk = NULL;
6316         if (!is_initial_commit() && stage_line_type == LINE_STAT_UNSTAGED)
6317                 chunk = stage_diff_find(view, line, LINE_DIFF_CHUNK);
6319         if (chunk) {
6320                 if (!prompt_yesno("Are you sure you want to revert changes?"))
6321                         return FALSE;
6323                 if (!stage_apply_chunk(view, chunk, TRUE)) {
6324                         report("Failed to revert chunk");
6325                         return FALSE;
6326                 }
6327                 return TRUE;
6329         } else {
6330                 return status_revert(stage_status.status ? &stage_status : NULL,
6331                                      stage_line_type, FALSE);
6332         }
6336 static void
6337 stage_next(struct view *view, struct line *line)
6339         int i;
6341         if (!stage_chunks) {
6342                 for (line = view->line; line < view->line + view->lines; line++) {
6343                         if (line->type != LINE_DIFF_CHUNK)
6344                                 continue;
6346                         if (!realloc_ints(&stage_chunk, stage_chunks, 1)) {
6347                                 report("Allocation failure");
6348                                 return;
6349                         }
6351                         stage_chunk[stage_chunks++] = line - view->line;
6352                 }
6353         }
6355         for (i = 0; i < stage_chunks; i++) {
6356                 if (stage_chunk[i] > view->lineno) {
6357                         do_scroll_view(view, stage_chunk[i] - view->lineno);
6358                         report("Chunk %d of %d", i + 1, stage_chunks);
6359                         return;
6360                 }
6361         }
6363         report("No next chunk found");
6366 static enum request
6367 stage_request(struct view *view, enum request request, struct line *line)
6369         switch (request) {
6370         case REQ_STATUS_UPDATE:
6371                 if (!stage_update(view, line))
6372                         return REQ_NONE;
6373                 break;
6375         case REQ_STATUS_REVERT:
6376                 if (!stage_revert(view, line))
6377                         return REQ_NONE;
6378                 break;
6380         case REQ_STAGE_NEXT:
6381                 if (stage_line_type == LINE_STAT_UNTRACKED) {
6382                         report("File is untracked; press %s to add",
6383                                get_key(KEYMAP_STAGE, REQ_STATUS_UPDATE));
6384                         return REQ_NONE;
6385                 }
6386                 stage_next(view, line);
6387                 return REQ_NONE;
6389         case REQ_EDIT:
6390                 if (!stage_status.new.name[0])
6391                         return request;
6392                 if (stage_status.status == 'D') {
6393                         report("File has been deleted.");
6394                         return REQ_NONE;
6395                 }
6397                 open_editor(stage_status.new.name);
6398                 break;
6400         case REQ_REFRESH:
6401                 /* Reload everything ... */
6402                 break;
6404         case REQ_VIEW_BLAME:
6405                 if (stage_status.new.name[0]) {
6406                         string_copy(opt_file, stage_status.new.name);
6407                         opt_ref[0] = 0;
6408                 }
6409                 return request;
6411         case REQ_ENTER:
6412                 return pager_request(view, request, line);
6414         default:
6415                 return request;
6416         }
6418         VIEW(REQ_VIEW_STATUS)->p_restore = TRUE;
6419         open_view(view, REQ_VIEW_STATUS, OPEN_REFRESH);
6421         /* Check whether the staged entry still exists, and close the
6422          * stage view if it doesn't. */
6423         if (!status_exists(&stage_status, stage_line_type)) {
6424                 status_restore(VIEW(REQ_VIEW_STATUS));
6425                 return REQ_VIEW_CLOSE;
6426         }
6428         if (stage_line_type == LINE_STAT_UNTRACKED) {
6429                 if (!suffixcmp(stage_status.new.name, -1, "/")) {
6430                         report("Cannot display a directory");
6431                         return REQ_NONE;
6432                 }
6434                 if (!prepare_update_file(view, stage_status.new.name)) {
6435                         report("Failed to open file: %s", strerror(errno));
6436                         return REQ_NONE;
6437                 }
6438         }
6439         open_view(view, REQ_VIEW_STAGE, OPEN_REFRESH);
6441         return REQ_NONE;
6444 static struct view_ops stage_ops = {
6445         "line",
6446         NULL,
6447         NULL,
6448         pager_read,
6449         pager_draw,
6450         stage_request,
6451         pager_grep,
6452         pager_select,
6453 };
6456 /*
6457  * Revision graph
6458  */
6460 struct commit {
6461         char id[SIZEOF_REV];            /* SHA1 ID. */
6462         char title[128];                /* First line of the commit message. */
6463         const char *author;             /* Author of the commit. */
6464         struct time time;               /* Date from the author ident. */
6465         struct ref_list *refs;          /* Repository references. */
6466         chtype graph[SIZEOF_REVGRAPH];  /* Ancestry chain graphics. */
6467         size_t graph_size;              /* The width of the graph array. */
6468         bool has_parents;               /* Rewritten --parents seen. */
6469 };
6471 /* Size of rev graph with no  "padding" columns */
6472 #define SIZEOF_REVITEMS (SIZEOF_REVGRAPH - (SIZEOF_REVGRAPH / 2))
6474 struct rev_graph {
6475         struct rev_graph *prev, *next, *parents;
6476         char rev[SIZEOF_REVITEMS][SIZEOF_REV];
6477         size_t size;
6478         struct commit *commit;
6479         size_t pos;
6480         unsigned int boundary:1;
6481 };
6483 /* Parents of the commit being visualized. */
6484 static struct rev_graph graph_parents[4];
6486 /* The current stack of revisions on the graph. */
6487 static struct rev_graph graph_stacks[4] = {
6488         { &graph_stacks[3], &graph_stacks[1], &graph_parents[0] },
6489         { &graph_stacks[0], &graph_stacks[2], &graph_parents[1] },
6490         { &graph_stacks[1], &graph_stacks[3], &graph_parents[2] },
6491         { &graph_stacks[2], &graph_stacks[0], &graph_parents[3] },
6492 };
6494 static inline bool
6495 graph_parent_is_merge(struct rev_graph *graph)
6497         return graph->parents->size > 1;
6500 static inline void
6501 append_to_rev_graph(struct rev_graph *graph, chtype symbol)
6503         struct commit *commit = graph->commit;
6505         if (commit->graph_size < ARRAY_SIZE(commit->graph) - 1)
6506                 commit->graph[commit->graph_size++] = symbol;
6509 static void
6510 clear_rev_graph(struct rev_graph *graph)
6512         graph->boundary = 0;
6513         graph->size = graph->pos = 0;
6514         graph->commit = NULL;
6515         memset(graph->parents, 0, sizeof(*graph->parents));
6518 static void
6519 done_rev_graph(struct rev_graph *graph)
6521         if (graph_parent_is_merge(graph) &&
6522             graph->pos < graph->size - 1 &&
6523             graph->next->size == graph->size + graph->parents->size - 1) {
6524                 size_t i = graph->pos + graph->parents->size - 1;
6526                 graph->commit->graph_size = i * 2;
6527                 while (i < graph->next->size - 1) {
6528                         append_to_rev_graph(graph, ' ');
6529                         append_to_rev_graph(graph, '\\');
6530                         i++;
6531                 }
6532         }
6534         clear_rev_graph(graph);
6537 static void
6538 push_rev_graph(struct rev_graph *graph, const char *parent)
6540         int i;
6542         /* "Collapse" duplicate parents lines.
6543          *
6544          * FIXME: This needs to also update update the drawn graph but
6545          * for now it just serves as a method for pruning graph lines. */
6546         for (i = 0; i < graph->size; i++)
6547                 if (!strncmp(graph->rev[i], parent, SIZEOF_REV))
6548                         return;
6550         if (graph->size < SIZEOF_REVITEMS) {
6551                 string_copy_rev(graph->rev[graph->size++], parent);
6552         }
6555 static chtype
6556 get_rev_graph_symbol(struct rev_graph *graph)
6558         chtype symbol;
6560         if (graph->boundary)
6561                 symbol = REVGRAPH_BOUND;
6562         else if (graph->parents->size == 0)
6563                 symbol = REVGRAPH_INIT;
6564         else if (graph_parent_is_merge(graph))
6565                 symbol = REVGRAPH_MERGE;
6566         else if (graph->pos >= graph->size)
6567                 symbol = REVGRAPH_BRANCH;
6568         else
6569                 symbol = REVGRAPH_COMMIT;
6571         return symbol;
6574 static void
6575 draw_rev_graph(struct rev_graph *graph)
6577         struct rev_filler {
6578                 chtype separator, line;
6579         };
6580         enum { DEFAULT, RSHARP, RDIAG, LDIAG };
6581         static struct rev_filler fillers[] = {
6582                 { ' ',  '|' },
6583                 { '`',  '.' },
6584                 { '\'', ' ' },
6585                 { '/',  ' ' },
6586         };
6587         chtype symbol = get_rev_graph_symbol(graph);
6588         struct rev_filler *filler;
6589         size_t i;
6591         fillers[DEFAULT].line = opt_line_graphics ? ACS_VLINE : '|';
6592         filler = &fillers[DEFAULT];
6594         for (i = 0; i < graph->pos; i++) {
6595                 append_to_rev_graph(graph, filler->line);
6596                 if (graph_parent_is_merge(graph->prev) &&
6597                     graph->prev->pos == i)
6598                         filler = &fillers[RSHARP];
6600                 append_to_rev_graph(graph, filler->separator);
6601         }
6603         /* Place the symbol for this revision. */
6604         append_to_rev_graph(graph, symbol);
6606         if (graph->prev->size > graph->size)
6607                 filler = &fillers[RDIAG];
6608         else
6609                 filler = &fillers[DEFAULT];
6611         i++;
6613         for (; i < graph->size; i++) {
6614                 append_to_rev_graph(graph, filler->separator);
6615                 append_to_rev_graph(graph, filler->line);
6616                 if (graph_parent_is_merge(graph->prev) &&
6617                     i < graph->prev->pos + graph->parents->size)
6618                         filler = &fillers[RSHARP];
6619                 if (graph->prev->size > graph->size)
6620                         filler = &fillers[LDIAG];
6621         }
6623         if (graph->prev->size > graph->size) {
6624                 append_to_rev_graph(graph, filler->separator);
6625                 if (filler->line != ' ')
6626                         append_to_rev_graph(graph, filler->line);
6627         }
6630 /* Prepare the next rev graph */
6631 static void
6632 prepare_rev_graph(struct rev_graph *graph)
6634         size_t i;
6636         /* First, traverse all lines of revisions up to the active one. */
6637         for (graph->pos = 0; graph->pos < graph->size; graph->pos++) {
6638                 if (!strcmp(graph->rev[graph->pos], graph->commit->id))
6639                         break;
6641                 push_rev_graph(graph->next, graph->rev[graph->pos]);
6642         }
6644         /* Interleave the new revision parent(s). */
6645         for (i = 0; !graph->boundary && i < graph->parents->size; i++)
6646                 push_rev_graph(graph->next, graph->parents->rev[i]);
6648         /* Lastly, put any remaining revisions. */
6649         for (i = graph->pos + 1; i < graph->size; i++)
6650                 push_rev_graph(graph->next, graph->rev[i]);
6653 static void
6654 update_rev_graph(struct view *view, struct rev_graph *graph)
6656         /* If this is the finalizing update ... */
6657         if (graph->commit)
6658                 prepare_rev_graph(graph);
6660         /* Graph visualization needs a one rev look-ahead,
6661          * so the first update doesn't visualize anything. */
6662         if (!graph->prev->commit)
6663                 return;
6665         if (view->lines > 2)
6666                 view->line[view->lines - 3].dirty = 1;
6667         if (view->lines > 1)
6668                 view->line[view->lines - 2].dirty = 1;
6669         draw_rev_graph(graph->prev);
6670         done_rev_graph(graph->prev->prev);
6674 /*
6675  * Main view backend
6676  */
6678 static const char *main_argv[SIZEOF_ARG] = {
6679         "git", "log", "--no-color", "--pretty=raw", "--parents",
6680                       "--topo-order", "%(head)", NULL
6681 };
6683 static bool
6684 main_draw(struct view *view, struct line *line, unsigned int lineno)
6686         struct commit *commit = line->data;
6688         if (!commit->author)
6689                 return FALSE;
6691         if (opt_date && draw_date(view, &commit->time))
6692                 return TRUE;
6694         if (opt_author && draw_author(view, commit->author))
6695                 return TRUE;
6697         if (opt_rev_graph && commit->graph_size &&
6698             draw_graphic(view, LINE_MAIN_REVGRAPH, commit->graph, commit->graph_size))
6699                 return TRUE;
6701         if (opt_show_refs && commit->refs) {
6702                 size_t i;
6704                 for (i = 0; i < commit->refs->size; i++) {
6705                         struct ref *ref = commit->refs->refs[i];
6706                         enum line_type type;
6708                         if (ref->head)
6709                                 type = LINE_MAIN_HEAD;
6710                         else if (ref->ltag)
6711                                 type = LINE_MAIN_LOCAL_TAG;
6712                         else if (ref->tag)
6713                                 type = LINE_MAIN_TAG;
6714                         else if (ref->tracked)
6715                                 type = LINE_MAIN_TRACKED;
6716                         else if (ref->remote)
6717                                 type = LINE_MAIN_REMOTE;
6718                         else
6719                                 type = LINE_MAIN_REF;
6721                         if (draw_text(view, type, "[", TRUE) ||
6722                             draw_text(view, type, ref->name, TRUE) ||
6723                             draw_text(view, type, "]", TRUE))
6724                                 return TRUE;
6726                         if (draw_text(view, LINE_DEFAULT, " ", TRUE))
6727                                 return TRUE;
6728                 }
6729         }
6731         draw_text(view, LINE_DEFAULT, commit->title, TRUE);
6732         return TRUE;
6735 /* Reads git log --pretty=raw output and parses it into the commit struct. */
6736 static bool
6737 main_read(struct view *view, char *line)
6739         static struct rev_graph *graph = graph_stacks;
6740         enum line_type type;
6741         struct commit *commit;
6743         if (!line) {
6744                 int i;
6746                 if (!view->lines && !view->parent)
6747                         die("No revisions match the given arguments.");
6748                 if (view->lines > 0) {
6749                         commit = view->line[view->lines - 1].data;
6750                         view->line[view->lines - 1].dirty = 1;
6751                         if (!commit->author) {
6752                                 view->lines--;
6753                                 free(commit);
6754                                 graph->commit = NULL;
6755                         }
6756                 }
6757                 update_rev_graph(view, graph);
6759                 for (i = 0; i < ARRAY_SIZE(graph_stacks); i++)
6760                         clear_rev_graph(&graph_stacks[i]);
6761                 return TRUE;
6762         }
6764         type = get_line_type(line);
6765         if (type == LINE_COMMIT) {
6766                 commit = calloc(1, sizeof(struct commit));
6767                 if (!commit)
6768                         return FALSE;
6770                 line += STRING_SIZE("commit ");
6771                 if (*line == '-') {
6772                         graph->boundary = 1;
6773                         line++;
6774                 }
6776                 string_copy_rev(commit->id, line);
6777                 commit->refs = get_ref_list(commit->id);
6778                 graph->commit = commit;
6779                 add_line_data(view, commit, LINE_MAIN_COMMIT);
6781                 while ((line = strchr(line, ' '))) {
6782                         line++;
6783                         push_rev_graph(graph->parents, line);
6784                         commit->has_parents = TRUE;
6785                 }
6786                 return TRUE;
6787         }
6789         if (!view->lines)
6790                 return TRUE;
6791         commit = view->line[view->lines - 1].data;
6793         switch (type) {
6794         case LINE_PARENT:
6795                 if (commit->has_parents)
6796                         break;
6797                 push_rev_graph(graph->parents, line + STRING_SIZE("parent "));
6798                 break;
6800         case LINE_AUTHOR:
6801                 parse_author_line(line + STRING_SIZE("author "),
6802                                   &commit->author, &commit->time);
6803                 update_rev_graph(view, graph);
6804                 graph = graph->next;
6805                 break;
6807         default:
6808                 /* Fill in the commit title if it has not already been set. */
6809                 if (commit->title[0])
6810                         break;
6812                 /* Require titles to start with a non-space character at the
6813                  * offset used by git log. */
6814                 if (strncmp(line, "    ", 4))
6815                         break;
6816                 line += 4;
6817                 /* Well, if the title starts with a whitespace character,
6818                  * try to be forgiving.  Otherwise we end up with no title. */
6819                 while (isspace(*line))
6820                         line++;
6821                 if (*line == '\0')
6822                         break;
6823                 /* FIXME: More graceful handling of titles; append "..." to
6824                  * shortened titles, etc. */
6826                 string_expand(commit->title, sizeof(commit->title), line, 1);
6827                 view->line[view->lines - 1].dirty = 1;
6828         }
6830         return TRUE;
6833 static enum request
6834 main_request(struct view *view, enum request request, struct line *line)
6836         enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
6838         switch (request) {
6839         case REQ_ENTER:
6840                 open_view(view, REQ_VIEW_DIFF, flags);
6841                 break;
6842         case REQ_REFRESH:
6843                 load_refs();
6844                 open_view(view, REQ_VIEW_MAIN, OPEN_REFRESH);
6845                 break;
6846         default:
6847                 return request;
6848         }
6850         return REQ_NONE;
6853 static bool
6854 grep_refs(struct ref_list *list, regex_t *regex)
6856         regmatch_t pmatch;
6857         size_t i;
6859         if (!opt_show_refs || !list)
6860                 return FALSE;
6862         for (i = 0; i < list->size; i++) {
6863                 if (regexec(regex, list->refs[i]->name, 1, &pmatch, 0) != REG_NOMATCH)
6864                         return TRUE;
6865         }
6867         return FALSE;
6870 static bool
6871 main_grep(struct view *view, struct line *line)
6873         struct commit *commit = line->data;
6874         const char *text[] = {
6875                 commit->title,
6876                 opt_author ? commit->author : "",
6877                 mkdate(&commit->time, opt_date),
6878                 NULL
6879         };
6881         return grep_text(view, text) || grep_refs(commit->refs, view->regex);
6884 static void
6885 main_select(struct view *view, struct line *line)
6887         struct commit *commit = line->data;
6889         string_copy_rev(view->ref, commit->id);
6890         string_copy_rev(ref_commit, view->ref);
6893 static struct view_ops main_ops = {
6894         "commit",
6895         main_argv,
6896         NULL,
6897         main_read,
6898         main_draw,
6899         main_request,
6900         main_grep,
6901         main_select,
6902 };
6905 /*
6906  * Status management
6907  */
6909 /* Whether or not the curses interface has been initialized. */
6910 static bool cursed = FALSE;
6912 /* Terminal hacks and workarounds. */
6913 static bool use_scroll_redrawwin;
6914 static bool use_scroll_status_wclear;
6916 /* The status window is used for polling keystrokes. */
6917 static WINDOW *status_win;
6919 /* Reading from the prompt? */
6920 static bool input_mode = FALSE;
6922 static bool status_empty = FALSE;
6924 /* Update status and title window. */
6925 static void
6926 report(const char *msg, ...)
6928         struct view *view = display[current_view];
6930         if (input_mode)
6931                 return;
6933         if (!view) {
6934                 char buf[SIZEOF_STR];
6935                 va_list args;
6937                 va_start(args, msg);
6938                 if (vsnprintf(buf, sizeof(buf), msg, args) >= sizeof(buf)) {
6939                         buf[sizeof(buf) - 1] = 0;
6940                         buf[sizeof(buf) - 2] = '.';
6941                         buf[sizeof(buf) - 3] = '.';
6942                         buf[sizeof(buf) - 4] = '.';
6943                 }
6944                 va_end(args);
6945                 die("%s", buf);
6946         }
6948         if (!status_empty || *msg) {
6949                 va_list args;
6951                 va_start(args, msg);
6953                 wmove(status_win, 0, 0);
6954                 if (view->has_scrolled && use_scroll_status_wclear)
6955                         wclear(status_win);
6956                 if (*msg) {
6957                         vwprintw(status_win, msg, args);
6958                         status_empty = FALSE;
6959                 } else {
6960                         status_empty = TRUE;
6961                 }
6962                 wclrtoeol(status_win);
6963                 wnoutrefresh(status_win);
6965                 va_end(args);
6966         }
6968         update_view_title(view);
6971 static void
6972 init_display(void)
6974         const char *term;
6975         int x, y;
6977         /* Initialize the curses library */
6978         if (isatty(STDIN_FILENO)) {
6979                 cursed = !!initscr();
6980                 opt_tty = stdin;
6981         } else {
6982                 /* Leave stdin and stdout alone when acting as a pager. */
6983                 opt_tty = fopen("/dev/tty", "r+");
6984                 if (!opt_tty)
6985                         die("Failed to open /dev/tty");
6986                 cursed = !!newterm(NULL, opt_tty, opt_tty);
6987         }
6989         if (!cursed)
6990                 die("Failed to initialize curses");
6992         nonl();         /* Disable conversion and detect newlines from input. */
6993         cbreak();       /* Take input chars one at a time, no wait for \n */
6994         noecho();       /* Don't echo input */
6995         leaveok(stdscr, FALSE);
6997         if (has_colors())
6998                 init_colors();
7000         getmaxyx(stdscr, y, x);
7001         status_win = newwin(1, 0, y - 1, 0);
7002         if (!status_win)
7003                 die("Failed to create status window");
7005         /* Enable keyboard mapping */
7006         keypad(status_win, TRUE);
7007         wbkgdset(status_win, get_line_attr(LINE_STATUS));
7009         TABSIZE = opt_tab_size;
7011         term = getenv("XTERM_VERSION") ? NULL : getenv("COLORTERM");
7012         if (term && !strcmp(term, "gnome-terminal")) {
7013                 /* In the gnome-terminal-emulator, the message from
7014                  * scrolling up one line when impossible followed by
7015                  * scrolling down one line causes corruption of the
7016                  * status line. This is fixed by calling wclear. */
7017                 use_scroll_status_wclear = TRUE;
7018                 use_scroll_redrawwin = FALSE;
7020         } else if (term && !strcmp(term, "xrvt-xpm")) {
7021                 /* No problems with full optimizations in xrvt-(unicode)
7022                  * and aterm. */
7023                 use_scroll_status_wclear = use_scroll_redrawwin = FALSE;
7025         } else {
7026                 /* When scrolling in (u)xterm the last line in the
7027                  * scrolling direction will update slowly. */
7028                 use_scroll_redrawwin = TRUE;
7029                 use_scroll_status_wclear = FALSE;
7030         }
7033 static int
7034 get_input(int prompt_position)
7036         struct view *view;
7037         int i, key, cursor_y, cursor_x;
7038         bool loading = FALSE;
7040         if (prompt_position)
7041                 input_mode = TRUE;
7043         while (TRUE) {
7044                 foreach_view (view, i) {
7045                         update_view(view);
7046                         if (view_is_displayed(view) && view->has_scrolled &&
7047                             use_scroll_redrawwin)
7048                                 redrawwin(view->win);
7049                         view->has_scrolled = FALSE;
7050                         if (view->pipe)
7051                                 loading = TRUE;
7052                 }
7054                 /* Update the cursor position. */
7055                 if (prompt_position) {
7056                         getbegyx(status_win, cursor_y, cursor_x);
7057                         cursor_x = prompt_position;
7058                 } else {
7059                         view = display[current_view];
7060                         getbegyx(view->win, cursor_y, cursor_x);
7061                         cursor_x = view->width - 1;
7062                         cursor_y += view->lineno - view->offset;
7063                 }
7064                 setsyx(cursor_y, cursor_x);
7066                 /* Refresh, accept single keystroke of input */
7067                 doupdate();
7068                 nodelay(status_win, loading);
7069                 key = wgetch(status_win);
7071                 /* wgetch() with nodelay() enabled returns ERR when
7072                  * there's no input. */
7073                 if (key == ERR) {
7075                 } else if (key == KEY_RESIZE) {
7076                         int height, width;
7078                         getmaxyx(stdscr, height, width);
7080                         wresize(status_win, 1, width);
7081                         mvwin(status_win, height - 1, 0);
7082                         wnoutrefresh(status_win);
7083                         resize_display();
7084                         redraw_display(TRUE);
7086                 } else {
7087                         input_mode = FALSE;
7088                         return key;
7089                 }
7090         }
7093 static char *
7094 prompt_input(const char *prompt, input_handler handler, void *data)
7096         enum input_status status = INPUT_OK;
7097         static char buf[SIZEOF_STR];
7098         size_t pos = 0;
7100         buf[pos] = 0;
7102         while (status == INPUT_OK || status == INPUT_SKIP) {
7103                 int key;
7105                 mvwprintw(status_win, 0, 0, "%s%.*s", prompt, pos, buf);
7106                 wclrtoeol(status_win);
7108                 key = get_input(pos + 1);
7109                 switch (key) {
7110                 case KEY_RETURN:
7111                 case KEY_ENTER:
7112                 case '\n':
7113                         status = pos ? INPUT_STOP : INPUT_CANCEL;
7114                         break;
7116                 case KEY_BACKSPACE:
7117                         if (pos > 0)
7118                                 buf[--pos] = 0;
7119                         else
7120                                 status = INPUT_CANCEL;
7121                         break;
7123                 case KEY_ESC:
7124                         status = INPUT_CANCEL;
7125                         break;
7127                 default:
7128                         if (pos >= sizeof(buf)) {
7129                                 report("Input string too long");
7130                                 return NULL;
7131                         }
7133                         status = handler(data, buf, key);
7134                         if (status == INPUT_OK)
7135                                 buf[pos++] = (char) key;
7136                 }
7137         }
7139         /* Clear the status window */
7140         status_empty = FALSE;
7141         report("");
7143         if (status == INPUT_CANCEL)
7144                 return NULL;
7146         buf[pos++] = 0;
7148         return buf;
7151 static enum input_status
7152 prompt_yesno_handler(void *data, char *buf, int c)
7154         if (c == 'y' || c == 'Y')
7155                 return INPUT_STOP;
7156         if (c == 'n' || c == 'N')
7157                 return INPUT_CANCEL;
7158         return INPUT_SKIP;
7161 static bool
7162 prompt_yesno(const char *prompt)
7164         char prompt2[SIZEOF_STR];
7166         if (!string_format(prompt2, "%s [Yy/Nn]", prompt))
7167                 return FALSE;
7169         return !!prompt_input(prompt2, prompt_yesno_handler, NULL);
7172 static enum input_status
7173 read_prompt_handler(void *data, char *buf, int c)
7175         return isprint(c) ? INPUT_OK : INPUT_SKIP;
7178 static char *
7179 read_prompt(const char *prompt)
7181         return prompt_input(prompt, read_prompt_handler, NULL);
7184 static bool prompt_menu(const char *prompt, const struct menu_item *items, int *selected)
7186         enum input_status status = INPUT_OK;
7187         int size = 0;
7189         while (items[size].text)
7190                 size++;
7192         while (status == INPUT_OK) {
7193                 const struct menu_item *item = &items[*selected];
7194                 int key;
7195                 int i;
7197                 mvwprintw(status_win, 0, 0, "%s (%d of %d) ",
7198                           prompt, *selected + 1, size);
7199                 if (item->hotkey)
7200                         wprintw(status_win, "[%c] ", (char) item->hotkey);
7201                 wprintw(status_win, "%s", item->text);
7202                 wclrtoeol(status_win);
7204                 key = get_input(COLS - 1);
7205                 switch (key) {
7206                 case KEY_RETURN:
7207                 case KEY_ENTER:
7208                 case '\n':
7209                         status = INPUT_STOP;
7210                         break;
7212                 case KEY_LEFT:
7213                 case KEY_UP:
7214                         *selected = *selected - 1;
7215                         if (*selected < 0)
7216                                 *selected = size - 1;
7217                         break;
7219                 case KEY_RIGHT:
7220                 case KEY_DOWN:
7221                         *selected = (*selected + 1) % size;
7222                         break;
7224                 case KEY_ESC:
7225                         status = INPUT_CANCEL;
7226                         break;
7228                 default:
7229                         for (i = 0; items[i].text; i++)
7230                                 if (items[i].hotkey == key) {
7231                                         *selected = i;
7232                                         status = INPUT_STOP;
7233                                         break;
7234                                 }
7235                 }
7236         }
7238         /* Clear the status window */
7239         status_empty = FALSE;
7240         report("");
7242         return status != INPUT_CANCEL;
7245 /*
7246  * Repository properties
7247  */
7249 static struct ref **refs = NULL;
7250 static size_t refs_size = 0;
7251 static struct ref *refs_head = NULL;
7253 static struct ref_list **ref_lists = NULL;
7254 static size_t ref_lists_size = 0;
7256 DEFINE_ALLOCATOR(realloc_refs, struct ref *, 256)
7257 DEFINE_ALLOCATOR(realloc_refs_list, struct ref *, 8)
7258 DEFINE_ALLOCATOR(realloc_ref_lists, struct ref_list *, 8)
7260 static int
7261 compare_refs(const void *ref1_, const void *ref2_)
7263         const struct ref *ref1 = *(const struct ref **)ref1_;
7264         const struct ref *ref2 = *(const struct ref **)ref2_;
7266         if (ref1->tag != ref2->tag)
7267                 return ref2->tag - ref1->tag;
7268         if (ref1->ltag != ref2->ltag)
7269                 return ref2->ltag - ref2->ltag;
7270         if (ref1->head != ref2->head)
7271                 return ref2->head - ref1->head;
7272         if (ref1->tracked != ref2->tracked)
7273                 return ref2->tracked - ref1->tracked;
7274         if (ref1->remote != ref2->remote)
7275                 return ref2->remote - ref1->remote;
7276         return strcmp(ref1->name, ref2->name);
7279 static void
7280 foreach_ref(bool (*visitor)(void *data, const struct ref *ref), void *data)
7282         size_t i;
7284         for (i = 0; i < refs_size; i++)
7285                 if (!visitor(data, refs[i]))
7286                         break;
7289 static struct ref *
7290 get_ref_head()
7292         return refs_head;
7295 static struct ref_list *
7296 get_ref_list(const char *id)
7298         struct ref_list *list;
7299         size_t i;
7301         for (i = 0; i < ref_lists_size; i++)
7302                 if (!strcmp(id, ref_lists[i]->id))
7303                         return ref_lists[i];
7305         if (!realloc_ref_lists(&ref_lists, ref_lists_size, 1))
7306                 return NULL;
7307         list = calloc(1, sizeof(*list));
7308         if (!list)
7309                 return NULL;
7311         for (i = 0; i < refs_size; i++) {
7312                 if (!strcmp(id, refs[i]->id) &&
7313                     realloc_refs_list(&list->refs, list->size, 1))
7314                         list->refs[list->size++] = refs[i];
7315         }
7317         if (!list->refs) {
7318                 free(list);
7319                 return NULL;
7320         }
7322         qsort(list->refs, list->size, sizeof(*list->refs), compare_refs);
7323         ref_lists[ref_lists_size++] = list;
7324         return list;
7327 static int
7328 read_ref(char *id, size_t idlen, char *name, size_t namelen)
7330         struct ref *ref = NULL;
7331         bool tag = FALSE;
7332         bool ltag = FALSE;
7333         bool remote = FALSE;
7334         bool tracked = FALSE;
7335         bool head = FALSE;
7336         int from = 0, to = refs_size - 1;
7338         if (!prefixcmp(name, "refs/tags/")) {
7339                 if (!suffixcmp(name, namelen, "^{}")) {
7340                         namelen -= 3;
7341                         name[namelen] = 0;
7342                 } else {
7343                         ltag = TRUE;
7344                 }
7346                 tag = TRUE;
7347                 namelen -= STRING_SIZE("refs/tags/");
7348                 name    += STRING_SIZE("refs/tags/");
7350         } else if (!prefixcmp(name, "refs/remotes/")) {
7351                 remote = TRUE;
7352                 namelen -= STRING_SIZE("refs/remotes/");
7353                 name    += STRING_SIZE("refs/remotes/");
7354                 tracked  = !strcmp(opt_remote, name);
7356         } else if (!prefixcmp(name, "refs/heads/")) {
7357                 namelen -= STRING_SIZE("refs/heads/");
7358                 name    += STRING_SIZE("refs/heads/");
7359                 if (!strncmp(opt_head, name, namelen))
7360                         return OK;
7362         } else if (!strcmp(name, "HEAD")) {
7363                 head     = TRUE;
7364                 if (*opt_head) {
7365                         namelen  = strlen(opt_head);
7366                         name     = opt_head;
7367                 }
7368         }
7370         /* If we are reloading or it's an annotated tag, replace the
7371          * previous SHA1 with the resolved commit id; relies on the fact
7372          * git-ls-remote lists the commit id of an annotated tag right
7373          * before the commit id it points to. */
7374         while (from <= to) {
7375                 size_t pos = (to + from) / 2;
7376                 int cmp = strcmp(name, refs[pos]->name);
7378                 if (!cmp) {
7379                         ref = refs[pos];
7380                         break;
7381                 }
7383                 if (cmp < 0)
7384                         to = pos - 1;
7385                 else
7386                         from = pos + 1;
7387         }
7389         if (!ref) {
7390                 if (!realloc_refs(&refs, refs_size, 1))
7391                         return ERR;
7392                 ref = calloc(1, sizeof(*ref) + namelen);
7393                 if (!ref)
7394                         return ERR;
7395                 memmove(refs + from + 1, refs + from,
7396                         (refs_size - from) * sizeof(*refs));
7397                 refs[from] = ref;
7398                 strncpy(ref->name, name, namelen);
7399                 refs_size++;
7400         }
7402         ref->head = head;
7403         ref->tag = tag;
7404         ref->ltag = ltag;
7405         ref->remote = remote;
7406         ref->tracked = tracked;
7407         string_copy_rev(ref->id, id);
7409         if (head)
7410                 refs_head = ref;
7411         return OK;
7414 static int
7415 load_refs(void)
7417         const char *head_argv[] = {
7418                 "git", "symbolic-ref", "HEAD", NULL
7419         };
7420         static const char *ls_remote_argv[SIZEOF_ARG] = {
7421                 "git", "ls-remote", opt_git_dir, NULL
7422         };
7423         static bool init = FALSE;
7424         size_t i;
7426         if (!init) {
7427                 if (!argv_from_env(ls_remote_argv, "TIG_LS_REMOTE"))
7428                         die("TIG_LS_REMOTE contains too many arguments");
7429                 init = TRUE;
7430         }
7432         if (!*opt_git_dir)
7433                 return OK;
7435         if (io_run_buf(head_argv, opt_head, sizeof(opt_head)) &&
7436             !prefixcmp(opt_head, "refs/heads/")) {
7437                 char *offset = opt_head + STRING_SIZE("refs/heads/");
7439                 memmove(opt_head, offset, strlen(offset) + 1);
7440         }
7442         refs_head = NULL;
7443         for (i = 0; i < refs_size; i++)
7444                 refs[i]->id[0] = 0;
7446         if (io_run_load(ls_remote_argv, "\t", read_ref) == ERR)
7447                 return ERR;
7449         /* Update the ref lists to reflect changes. */
7450         for (i = 0; i < ref_lists_size; i++) {
7451                 struct ref_list *list = ref_lists[i];
7452                 size_t old, new;
7454                 for (old = new = 0; old < list->size; old++)
7455                         if (!strcmp(list->id, list->refs[old]->id))
7456                                 list->refs[new++] = list->refs[old];
7457                 list->size = new;
7458         }
7460         return OK;
7463 static void
7464 set_remote_branch(const char *name, const char *value, size_t valuelen)
7466         if (!strcmp(name, ".remote")) {
7467                 string_ncopy(opt_remote, value, valuelen);
7469         } else if (*opt_remote && !strcmp(name, ".merge")) {
7470                 size_t from = strlen(opt_remote);
7472                 if (!prefixcmp(value, "refs/heads/"))
7473                         value += STRING_SIZE("refs/heads/");
7475                 if (!string_format_from(opt_remote, &from, "/%s", value))
7476                         opt_remote[0] = 0;
7477         }
7480 static void
7481 set_repo_config_option(char *name, char *value, int (*cmd)(int, const char **))
7483         const char *argv[SIZEOF_ARG] = { name, "=" };
7484         int argc = 1 + (cmd == option_set_command);
7485         int error = ERR;
7487         if (!argv_from_string(argv, &argc, value))
7488                 config_msg = "Too many option arguments";
7489         else
7490                 error = cmd(argc, argv);
7492         if (error == ERR)
7493                 warn("Option 'tig.%s': %s", name, config_msg);
7496 static bool
7497 set_environment_variable(const char *name, const char *value)
7499         size_t len = strlen(name) + 1 + strlen(value) + 1;
7500         char *env = malloc(len);
7502         if (env &&
7503             string_nformat(env, len, NULL, "%s=%s", name, value) &&
7504             putenv(env) == 0)
7505                 return TRUE;
7506         free(env);
7507         return FALSE;
7510 static void
7511 set_work_tree(const char *value)
7513         char cwd[SIZEOF_STR];
7515         if (!getcwd(cwd, sizeof(cwd)))
7516                 die("Failed to get cwd path: %s", strerror(errno));
7517         if (chdir(opt_git_dir) < 0)
7518                 die("Failed to chdir(%s): %s", strerror(errno));
7519         if (!getcwd(opt_git_dir, sizeof(opt_git_dir)))
7520                 die("Failed to get git path: %s", strerror(errno));
7521         if (chdir(cwd) < 0)
7522                 die("Failed to chdir(%s): %s", cwd, strerror(errno));
7523         if (chdir(value) < 0)
7524                 die("Failed to chdir(%s): %s", value, strerror(errno));
7525         if (!getcwd(cwd, sizeof(cwd)))
7526                 die("Failed to get cwd path: %s", strerror(errno));
7527         if (!set_environment_variable("GIT_WORK_TREE", cwd))
7528                 die("Failed to set GIT_WORK_TREE to '%s'", cwd);
7529         if (!set_environment_variable("GIT_DIR", opt_git_dir))
7530                 die("Failed to set GIT_DIR to '%s'", opt_git_dir);
7531         opt_is_inside_work_tree = TRUE;
7534 static int
7535 read_repo_config_option(char *name, size_t namelen, char *value, size_t valuelen)
7537         if (!strcmp(name, "i18n.commitencoding"))
7538                 string_ncopy(opt_encoding, value, valuelen);
7540         else if (!strcmp(name, "core.editor"))
7541                 string_ncopy(opt_editor, value, valuelen);
7543         else if (!strcmp(name, "core.worktree"))
7544                 set_work_tree(value);
7546         else if (!prefixcmp(name, "tig.color."))
7547                 set_repo_config_option(name + 10, value, option_color_command);
7549         else if (!prefixcmp(name, "tig.bind."))
7550                 set_repo_config_option(name + 9, value, option_bind_command);
7552         else if (!prefixcmp(name, "tig."))
7553                 set_repo_config_option(name + 4, value, option_set_command);
7555         else if (*opt_head && !prefixcmp(name, "branch.") &&
7556                  !strncmp(name + 7, opt_head, strlen(opt_head)))
7557                 set_remote_branch(name + 7 + strlen(opt_head), value, valuelen);
7559         return OK;
7562 static int
7563 load_git_config(void)
7565         const char *config_list_argv[] = { "git", "config", "--list", NULL };
7567         return io_run_load(config_list_argv, "=", read_repo_config_option);
7570 static int
7571 read_repo_info(char *name, size_t namelen, char *value, size_t valuelen)
7573         if (!opt_git_dir[0]) {
7574                 string_ncopy(opt_git_dir, name, namelen);
7576         } else if (opt_is_inside_work_tree == -1) {
7577                 /* This can be 3 different values depending on the
7578                  * version of git being used. If git-rev-parse does not
7579                  * understand --is-inside-work-tree it will simply echo
7580                  * the option else either "true" or "false" is printed.
7581                  * Default to true for the unknown case. */
7582                 opt_is_inside_work_tree = strcmp(name, "false") ? TRUE : FALSE;
7584         } else if (*name == '.') {
7585                 string_ncopy(opt_cdup, name, namelen);
7587         } else {
7588                 string_ncopy(opt_prefix, name, namelen);
7589         }
7591         return OK;
7594 static int
7595 load_repo_info(void)
7597         const char *rev_parse_argv[] = {
7598                 "git", "rev-parse", "--git-dir", "--is-inside-work-tree",
7599                         "--show-cdup", "--show-prefix", NULL
7600         };
7602         return io_run_load(rev_parse_argv, "=", read_repo_info);
7606 /*
7607  * Main
7608  */
7610 static const char usage[] =
7611 "tig " TIG_VERSION " (" __DATE__ ")\n"
7612 "\n"
7613 "Usage: tig        [options] [revs] [--] [paths]\n"
7614 "   or: tig show   [options] [revs] [--] [paths]\n"
7615 "   or: tig blame  [rev] path\n"
7616 "   or: tig status\n"
7617 "   or: tig <      [git command output]\n"
7618 "\n"
7619 "Options:\n"
7620 "  -v, --version   Show version and exit\n"
7621 "  -h, --help      Show help message and exit";
7623 static void __NORETURN
7624 quit(int sig)
7626         /* XXX: Restore tty modes and let the OS cleanup the rest! */
7627         if (cursed)
7628                 endwin();
7629         exit(0);
7632 static void __NORETURN
7633 die(const char *err, ...)
7635         va_list args;
7637         endwin();
7639         va_start(args, err);
7640         fputs("tig: ", stderr);
7641         vfprintf(stderr, err, args);
7642         fputs("\n", stderr);
7643         va_end(args);
7645         exit(1);
7648 static void
7649 warn(const char *msg, ...)
7651         va_list args;
7653         va_start(args, msg);
7654         fputs("tig warning: ", stderr);
7655         vfprintf(stderr, msg, args);
7656         fputs("\n", stderr);
7657         va_end(args);
7660 static enum request
7661 parse_options(int argc, const char *argv[])
7663         enum request request = REQ_VIEW_MAIN;
7664         const char *subcommand;
7665         bool seen_dashdash = FALSE;
7666         /* XXX: This is vulnerable to the user overriding options
7667          * required for the main view parser. */
7668         const char *custom_argv[SIZEOF_ARG] = {
7669                 "git", "log", "--no-color", "--pretty=raw", "--parents",
7670                         "--topo-order", NULL
7671         };
7672         int i, j = 6;
7674         if (!isatty(STDIN_FILENO)) {
7675                 io_open(&VIEW(REQ_VIEW_PAGER)->io, "");
7676                 return REQ_VIEW_PAGER;
7677         }
7679         if (argc <= 1)
7680                 return REQ_NONE;
7682         subcommand = argv[1];
7683         if (!strcmp(subcommand, "status")) {
7684                 if (argc > 2)
7685                         warn("ignoring arguments after `%s'", subcommand);
7686                 return REQ_VIEW_STATUS;
7688         } else if (!strcmp(subcommand, "blame")) {
7689                 if (argc <= 2 || argc > 4)
7690                         die("invalid number of options to blame\n\n%s", usage);
7692                 i = 2;
7693                 if (argc == 4) {
7694                         string_ncopy(opt_ref, argv[i], strlen(argv[i]));
7695                         i++;
7696                 }
7698                 string_ncopy(opt_file, argv[i], strlen(argv[i]));
7699                 return REQ_VIEW_BLAME;
7701         } else if (!strcmp(subcommand, "show")) {
7702                 request = REQ_VIEW_DIFF;
7704         } else {
7705                 subcommand = NULL;
7706         }
7708         if (subcommand) {
7709                 custom_argv[1] = subcommand;
7710                 j = 2;
7711         }
7713         for (i = 1 + !!subcommand; i < argc; i++) {
7714                 const char *opt = argv[i];
7716                 if (seen_dashdash || !strcmp(opt, "--")) {
7717                         seen_dashdash = TRUE;
7719                 } else if (!strcmp(opt, "-v") || !strcmp(opt, "--version")) {
7720                         printf("tig version %s\n", TIG_VERSION);
7721                         quit(0);
7723                 } else if (!strcmp(opt, "-h") || !strcmp(opt, "--help")) {
7724                         printf("%s\n", usage);
7725                         quit(0);
7726                 }
7728                 custom_argv[j++] = opt;
7729                 if (j >= ARRAY_SIZE(custom_argv))
7730                         die("command too long");
7731         }
7733         if (!prepare_update(VIEW(request), custom_argv, NULL))
7734                 die("Failed to format arguments");
7736         return request;
7739 int
7740 main(int argc, const char *argv[])
7742         const char *codeset = "UTF-8";
7743         enum request request = parse_options(argc, argv);
7744         struct view *view;
7745         size_t i;
7747         signal(SIGINT, quit);
7748         signal(SIGPIPE, SIG_IGN);
7750         if (setlocale(LC_ALL, "")) {
7751                 codeset = nl_langinfo(CODESET);
7752         }
7754         if (load_repo_info() == ERR)
7755                 die("Failed to load repo info.");
7757         if (load_options() == ERR)
7758                 die("Failed to load user config.");
7760         if (load_git_config() == ERR)
7761                 die("Failed to load repo config.");
7763         /* Require a git repository unless when running in pager mode. */
7764         if (!opt_git_dir[0] && request != REQ_VIEW_PAGER)
7765                 die("Not a git repository");
7767         if (*opt_encoding && strcmp(codeset, "UTF-8")) {
7768                 opt_iconv_in = iconv_open("UTF-8", opt_encoding);
7769                 if (opt_iconv_in == ICONV_NONE)
7770                         die("Failed to initialize character set conversion");
7771         }
7773         if (codeset && strcmp(codeset, "UTF-8")) {
7774                 opt_iconv_out = iconv_open(codeset, "UTF-8");
7775                 if (opt_iconv_out == ICONV_NONE)
7776                         die("Failed to initialize character set conversion");
7777         }
7779         if (load_refs() == ERR)
7780                 die("Failed to load refs.");
7782         foreach_view (view, i)
7783                 if (!argv_from_env(view->ops->argv, view->cmd_env))
7784                         die("Too many arguments in the `%s` environment variable",
7785                             view->cmd_env);
7787         init_display();
7789         if (request != REQ_NONE)
7790                 open_view(NULL, request, OPEN_PREPARED);
7791         request = request == REQ_NONE ? REQ_VIEW_MAIN : REQ_NONE;
7793         while (view_driver(display[current_view], request)) {
7794                 int key = get_input(0);
7796                 view = display[current_view];
7797                 request = get_keybinding(view->keymap, key);
7799                 /* Some low-level request handling. This keeps access to
7800                  * status_win restricted. */
7801                 switch (request) {
7802                 case REQ_PROMPT:
7803                 {
7804                         char *cmd = read_prompt(":");
7806                         if (cmd && isdigit(*cmd)) {
7807                                 int lineno = view->lineno + 1;
7809                                 if (parse_int(&lineno, cmd, 1, view->lines + 1) == OK) {
7810                                         select_view_line(view, lineno - 1);
7811                                         report("");
7812                                 } else {
7813                                         report("Unable to parse '%s' as a line number", cmd);
7814                                 }
7816                         } else if (cmd) {
7817                                 struct view *next = VIEW(REQ_VIEW_PAGER);
7818                                 const char *argv[SIZEOF_ARG] = { "git" };
7819                                 int argc = 1;
7821                                 /* When running random commands, initially show the
7822                                  * command in the title. However, it maybe later be
7823                                  * overwritten if a commit line is selected. */
7824                                 string_ncopy(next->ref, cmd, strlen(cmd));
7826                                 if (!argv_from_string(argv, &argc, cmd)) {
7827                                         report("Too many arguments");
7828                                 } else if (!prepare_update(next, argv, NULL)) {
7829                                         report("Failed to format command");
7830                                 } else {
7831                                         open_view(view, REQ_VIEW_PAGER, OPEN_PREPARED);
7832                                 }
7833                         }
7835                         request = REQ_NONE;
7836                         break;
7837                 }
7838                 case REQ_SEARCH:
7839                 case REQ_SEARCH_BACK:
7840                 {
7841                         const char *prompt = request == REQ_SEARCH ? "/" : "?";
7842                         char *search = read_prompt(prompt);
7844                         if (search)
7845                                 string_ncopy(opt_search, search, strlen(search));
7846                         else if (*opt_search)
7847                                 request = request == REQ_SEARCH ?
7848                                         REQ_FIND_NEXT :
7849                                         REQ_FIND_PREV;
7850                         else
7851                                 request = REQ_NONE;
7852                         break;
7853                 }
7854                 default:
7855                         break;
7856                 }
7857         }
7859         quit(0);
7861         return 0;