![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
1 /* Copyright (c) 2006-2009 Jonas Fonseca <fonseca@diku.dk>
2 *
3 * This program is free software; you can redistribute it and/or
4 * modify it under the terms of the GNU General Public License as
5 * published by the Free Software Foundation; either version 2 of
6 * the License, or (at your option) any later version.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 */
14 #ifdef HAVE_CONFIG_H
15 #include "config.h"
16 #endif
18 #ifndef TIG_VERSION
19 #define TIG_VERSION "unknown-version"
20 #endif
22 #ifndef DEBUG
23 #define NDEBUG
24 #endif
26 #include <assert.h>
27 #include <errno.h>
28 #include <ctype.h>
29 #include <signal.h>
30 #include <stdarg.h>
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #include <sys/types.h>
35 #include <sys/wait.h>
36 #include <sys/stat.h>
37 #include <sys/select.h>
38 #include <unistd.h>
39 #include <time.h>
40 #include <fcntl.h>
42 #include <regex.h>
44 #include <locale.h>
45 #include <langinfo.h>
46 #include <iconv.h>
48 /* ncurses(3): Must be defined to have extended wide-character functions. */
49 #define _XOPEN_SOURCE_EXTENDED
51 #ifdef HAVE_NCURSESW_NCURSES_H
52 #include <ncursesw/ncurses.h>
53 #else
54 #ifdef HAVE_NCURSES_NCURSES_H
55 #include <ncurses/ncurses.h>
56 #else
57 #include <ncurses.h>
58 #endif
59 #endif
61 #if __GNUC__ >= 3
62 #define __NORETURN __attribute__((__noreturn__))
63 #else
64 #define __NORETURN
65 #endif
67 static void __NORETURN die(const char *err, ...);
68 static void warn(const char *msg, ...);
69 static void report(const char *msg, ...);
70 static void set_nonblocking_input(bool loading);
71 static int load_refs(void);
72 static size_t utf8_length(const char **string, size_t col, int *width, size_t max_width, int *trimmed, bool reserve);
74 #define ABS(x) ((x) >= 0 ? (x) : -(x))
75 #define MIN(x, y) ((x) < (y) ? (x) : (y))
77 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
78 #define STRING_SIZE(x) (sizeof(x) - 1)
80 #define SIZEOF_STR 1024 /* Default string size. */
81 #define SIZEOF_REF 256 /* Size of symbolic or SHA1 ID. */
82 #define SIZEOF_REV 41 /* Holds a SHA-1 and an ending NUL. */
83 #define SIZEOF_ARG 32 /* Default argument array size. */
85 /* Revision graph */
87 #define REVGRAPH_INIT 'I'
88 #define REVGRAPH_MERGE 'M'
89 #define REVGRAPH_BRANCH '+'
90 #define REVGRAPH_COMMIT '*'
91 #define REVGRAPH_BOUND '^'
93 #define SIZEOF_REVGRAPH 19 /* Size of revision ancestry graphics. */
95 /* This color name can be used to refer to the default term colors. */
96 #define COLOR_DEFAULT (-1)
98 #define ICONV_NONE ((iconv_t) -1)
99 #ifndef ICONV_CONST
100 #define ICONV_CONST /* nothing */
101 #endif
103 /* The format and size of the date column in the main view. */
104 #define DATE_FORMAT "%Y-%m-%d %H:%M"
105 #define DATE_COLS STRING_SIZE("2006-04-29 14:21 ")
107 #define AUTHOR_COLS 20
108 #define ID_COLS 8
110 /* The default interval between line numbers. */
111 #define NUMBER_INTERVAL 5
112 #define SCROLL_INTERVAL 1
114 #define TAB_SIZE 8
116 #define SCALE_SPLIT_VIEW(height) ((height) * 2 / 3)
118 #define NULL_ID "0000000000000000000000000000000000000000"
120 #ifndef GIT_CONFIG
121 #define GIT_CONFIG "config"
122 #endif
124 /* Some ASCII-shorthands fitted into the ncurses namespace. */
125 #define KEY_TAB '\t'
126 #define KEY_RETURN '\r'
127 #define KEY_ESC 27
130 struct ref {
131 char *name; /* Ref name; tag or head names are shortened. */
132 char id[SIZEOF_REV]; /* Commit SHA1 ID */
133 unsigned int head:1; /* Is it the current HEAD? */
134 unsigned int tag:1; /* Is it a tag? */
135 unsigned int ltag:1; /* If so, is the tag local? */
136 unsigned int remote:1; /* Is it a remote ref? */
137 unsigned int tracked:1; /* Is it the remote for the current HEAD? */
138 unsigned int next:1; /* For ref lists: are there more refs? */
139 };
141 static struct ref **get_refs(const char *id);
143 enum format_flags {
144 FORMAT_ALL, /* Perform replacement in all arguments. */
145 FORMAT_DASH, /* Perform replacement up until "--". */
146 FORMAT_NONE /* No replacement should be performed. */
147 };
149 static bool format_argv(const char *dst[], const char *src[], enum format_flags flags);
151 enum input_status {
152 INPUT_OK,
153 INPUT_SKIP,
154 INPUT_STOP,
155 INPUT_CANCEL
156 };
158 typedef enum input_status (*input_handler)(void *data, char *buf, int c);
160 static char *prompt_input(const char *prompt, input_handler handler, void *data);
161 static bool prompt_yesno(const char *prompt);
163 /*
164 * String helpers
165 */
167 static inline void
168 string_ncopy_do(char *dst, size_t dstlen, const char *src, size_t srclen)
169 {
170 if (srclen > dstlen - 1)
171 srclen = dstlen - 1;
173 strncpy(dst, src, srclen);
174 dst[srclen] = 0;
175 }
177 /* Shorthands for safely copying into a fixed buffer. */
179 #define string_copy(dst, src) \
180 string_ncopy_do(dst, sizeof(dst), src, sizeof(src))
182 #define string_ncopy(dst, src, srclen) \
183 string_ncopy_do(dst, sizeof(dst), src, srclen)
185 #define string_copy_rev(dst, src) \
186 string_ncopy_do(dst, SIZEOF_REV, src, SIZEOF_REV - 1)
188 #define string_add(dst, from, src) \
189 string_ncopy_do(dst + (from), sizeof(dst) - (from), src, sizeof(src))
191 static size_t
192 string_expand_length(const char *line, int tabsize)
193 {
194 size_t size, pos;
196 for (size = pos = 0; line[pos]; pos++) {
197 if (line[pos] == '\t' && tabsize > 0)
198 size += tabsize - (size % tabsize);
199 else
200 size++;
201 }
202 return size;
203 }
205 static void
206 string_expand(char *dst, size_t dstlen, const char *src, int tabsize)
207 {
208 size_t size, pos;
210 for (size = pos = 0; size < dstlen - 1 && src[pos]; pos++) {
211 if (src[pos] == '\t') {
212 size_t expanded = tabsize - (size % tabsize);
214 if (expanded + size >= dstlen - 1)
215 expanded = dstlen - size - 1;
216 memcpy(dst + size, " ", expanded);
217 size += expanded;
218 } else {
219 dst[size++] = src[pos];
220 }
221 }
223 dst[size] = 0;
224 }
226 static char *
227 chomp_string(char *name)
228 {
229 int namelen;
231 while (isspace(*name))
232 name++;
234 namelen = strlen(name) - 1;
235 while (namelen > 0 && isspace(name[namelen]))
236 name[namelen--] = 0;
238 return name;
239 }
241 static bool
242 string_nformat(char *buf, size_t bufsize, size_t *bufpos, const char *fmt, ...)
243 {
244 va_list args;
245 size_t pos = bufpos ? *bufpos : 0;
247 va_start(args, fmt);
248 pos += vsnprintf(buf + pos, bufsize - pos, fmt, args);
249 va_end(args);
251 if (bufpos)
252 *bufpos = pos;
254 return pos >= bufsize ? FALSE : TRUE;
255 }
257 #define string_format(buf, fmt, args...) \
258 string_nformat(buf, sizeof(buf), NULL, fmt, args)
260 #define string_format_from(buf, from, fmt, args...) \
261 string_nformat(buf, sizeof(buf), from, fmt, args)
263 static int
264 string_enum_compare(const char *str1, const char *str2, int len)
265 {
266 size_t i;
268 #define string_enum_sep(x) ((x) == '-' || (x) == '_' || (x) == '.')
270 /* Diff-Header == DIFF_HEADER */
271 for (i = 0; i < len; i++) {
272 if (toupper(str1[i]) == toupper(str2[i]))
273 continue;
275 if (string_enum_sep(str1[i]) &&
276 string_enum_sep(str2[i]))
277 continue;
279 return str1[i] - str2[i];
280 }
282 return 0;
283 }
285 struct enum_map {
286 const char *name;
287 int namelen;
288 int value;
289 };
291 #define ENUM_MAP(name, value) { name, STRING_SIZE(name), value }
293 static bool
294 map_enum_do(struct enum_map *map, size_t map_size, int *value, const char *name)
295 {
296 size_t namelen = strlen(name);
297 int i;
299 for (i = 0; i < map_size; i++)
300 if (namelen == map[i].namelen &&
301 !string_enum_compare(name, map[i].name, namelen)) {
302 *value = map[i].value;
303 return TRUE;
304 }
306 return FALSE;
307 }
309 #define map_enum(attr, map, name) \
310 map_enum_do(map, ARRAY_SIZE(map), attr, name)
312 #define prefixcmp(str1, str2) \
313 strncmp(str1, str2, STRING_SIZE(str2))
315 static inline int
316 suffixcmp(const char *str, int slen, const char *suffix)
317 {
318 size_t len = slen >= 0 ? slen : strlen(str);
319 size_t suffixlen = strlen(suffix);
321 return suffixlen < len ? strcmp(str + len - suffixlen, suffix) : -1;
322 }
325 static bool
326 argv_from_string(const char *argv[SIZEOF_ARG], int *argc, char *cmd)
327 {
328 int valuelen;
330 while (*cmd && *argc < SIZEOF_ARG && (valuelen = strcspn(cmd, " \t"))) {
331 bool advance = cmd[valuelen] != 0;
333 cmd[valuelen] = 0;
334 argv[(*argc)++] = chomp_string(cmd);
335 cmd = chomp_string(cmd + valuelen + advance);
336 }
338 if (*argc < SIZEOF_ARG)
339 argv[*argc] = NULL;
340 return *argc < SIZEOF_ARG;
341 }
343 static void
344 argv_from_env(const char **argv, const char *name)
345 {
346 char *env = argv ? getenv(name) : NULL;
347 int argc = 0;
349 if (env && *env)
350 env = strdup(env);
351 if (env && !argv_from_string(argv, &argc, env))
352 die("Too many arguments in the `%s` environment variable", name);
353 }
356 /*
357 * Executing external commands.
358 */
360 enum io_type {
361 IO_FD, /* File descriptor based IO. */
362 IO_BG, /* Execute command in the background. */
363 IO_FG, /* Execute command with same std{in,out,err}. */
364 IO_RD, /* Read only fork+exec IO. */
365 IO_WR, /* Write only fork+exec IO. */
366 IO_AP, /* Append fork+exec output to file. */
367 };
369 struct io {
370 enum io_type type; /* The requested type of pipe. */
371 const char *dir; /* Directory from which to execute. */
372 pid_t pid; /* Pipe for reading or writing. */
373 int pipe; /* Pipe end for reading or writing. */
374 int error; /* Error status. */
375 const char *argv[SIZEOF_ARG]; /* Shell command arguments. */
376 char *buf; /* Read buffer. */
377 size_t bufalloc; /* Allocated buffer size. */
378 size_t bufsize; /* Buffer content size. */
379 char *bufpos; /* Current buffer position. */
380 unsigned int eof:1; /* Has end of file been reached. */
381 };
383 static void
384 reset_io(struct io *io)
385 {
386 io->pipe = -1;
387 io->pid = 0;
388 io->buf = io->bufpos = NULL;
389 io->bufalloc = io->bufsize = 0;
390 io->error = 0;
391 io->eof = 0;
392 }
394 static void
395 init_io(struct io *io, const char *dir, enum io_type type)
396 {
397 reset_io(io);
398 io->type = type;
399 io->dir = dir;
400 }
402 static bool
403 init_io_rd(struct io *io, const char *argv[], const char *dir,
404 enum format_flags flags)
405 {
406 init_io(io, dir, IO_RD);
407 return format_argv(io->argv, argv, flags);
408 }
410 static bool
411 io_open(struct io *io, const char *name)
412 {
413 init_io(io, NULL, IO_FD);
414 io->pipe = *name ? open(name, O_RDONLY) : STDIN_FILENO;
415 return io->pipe != -1;
416 }
418 static bool
419 kill_io(struct io *io)
420 {
421 return io->pid == 0 || kill(io->pid, SIGKILL) != -1;
422 }
424 static bool
425 done_io(struct io *io)
426 {
427 pid_t pid = io->pid;
429 if (io->pipe != -1)
430 close(io->pipe);
431 free(io->buf);
432 reset_io(io);
434 while (pid > 0) {
435 int status;
436 pid_t waiting = waitpid(pid, &status, 0);
438 if (waiting < 0) {
439 if (errno == EINTR)
440 continue;
441 report("waitpid failed (%s)", strerror(errno));
442 return FALSE;
443 }
445 return waiting == pid &&
446 !WIFSIGNALED(status) &&
447 WIFEXITED(status) &&
448 !WEXITSTATUS(status);
449 }
451 return TRUE;
452 }
454 static bool
455 start_io(struct io *io)
456 {
457 int pipefds[2] = { -1, -1 };
459 if (io->type == IO_FD)
460 return TRUE;
462 if ((io->type == IO_RD || io->type == IO_WR) &&
463 pipe(pipefds) < 0)
464 return FALSE;
465 else if (io->type == IO_AP)
466 pipefds[1] = io->pipe;
468 if ((io->pid = fork())) {
469 if (pipefds[!(io->type == IO_WR)] != -1)
470 close(pipefds[!(io->type == IO_WR)]);
471 if (io->pid != -1) {
472 io->pipe = pipefds[!!(io->type == IO_WR)];
473 return TRUE;
474 }
476 } else {
477 if (io->type != IO_FG) {
478 int devnull = open("/dev/null", O_RDWR);
479 int readfd = io->type == IO_WR ? pipefds[0] : devnull;
480 int writefd = (io->type == IO_RD || io->type == IO_AP)
481 ? pipefds[1] : devnull;
483 dup2(readfd, STDIN_FILENO);
484 dup2(writefd, STDOUT_FILENO);
485 dup2(devnull, STDERR_FILENO);
487 close(devnull);
488 if (pipefds[0] != -1)
489 close(pipefds[0]);
490 if (pipefds[1] != -1)
491 close(pipefds[1]);
492 }
494 if (io->dir && *io->dir && chdir(io->dir) == -1)
495 die("Failed to change directory: %s", strerror(errno));
497 execvp(io->argv[0], (char *const*) io->argv);
498 die("Failed to execute program: %s", strerror(errno));
499 }
501 if (pipefds[!!(io->type == IO_WR)] != -1)
502 close(pipefds[!!(io->type == IO_WR)]);
503 return FALSE;
504 }
506 static bool
507 run_io(struct io *io, const char **argv, const char *dir, enum io_type type)
508 {
509 init_io(io, dir, type);
510 if (!format_argv(io->argv, argv, FORMAT_NONE))
511 return FALSE;
512 return start_io(io);
513 }
515 static int
516 run_io_do(struct io *io)
517 {
518 return start_io(io) && done_io(io);
519 }
521 static int
522 run_io_bg(const char **argv)
523 {
524 struct io io = {};
526 init_io(&io, NULL, IO_BG);
527 if (!format_argv(io.argv, argv, FORMAT_NONE))
528 return FALSE;
529 return run_io_do(&io);
530 }
532 static bool
533 run_io_fg(const char **argv, const char *dir)
534 {
535 struct io io = {};
537 init_io(&io, dir, IO_FG);
538 if (!format_argv(io.argv, argv, FORMAT_NONE))
539 return FALSE;
540 return run_io_do(&io);
541 }
543 static bool
544 run_io_append(const char **argv, enum format_flags flags, int fd)
545 {
546 struct io io = {};
548 init_io(&io, NULL, IO_AP);
549 io.pipe = fd;
550 if (format_argv(io.argv, argv, flags))
551 return run_io_do(&io);
552 close(fd);
553 return FALSE;
554 }
556 static bool
557 run_io_rd(struct io *io, const char **argv, enum format_flags flags)
558 {
559 return init_io_rd(io, argv, NULL, flags) && start_io(io);
560 }
562 static bool
563 io_eof(struct io *io)
564 {
565 return io->eof;
566 }
568 static int
569 io_error(struct io *io)
570 {
571 return io->error;
572 }
574 static bool
575 io_strerror(struct io *io)
576 {
577 return strerror(io->error);
578 }
580 static bool
581 io_can_read(struct io *io)
582 {
583 struct timeval tv = { 0, 500 };
584 fd_set fds;
586 FD_ZERO(&fds);
587 FD_SET(io->pipe, &fds);
589 return select(io->pipe + 1, &fds, NULL, NULL, &tv) > 0;
590 }
592 static ssize_t
593 io_read(struct io *io, void *buf, size_t bufsize)
594 {
595 do {
596 ssize_t readsize = read(io->pipe, buf, bufsize);
598 if (readsize < 0 && (errno == EAGAIN || errno == EINTR))
599 continue;
600 else if (readsize == -1)
601 io->error = errno;
602 else if (readsize == 0)
603 io->eof = 1;
604 return readsize;
605 } while (1);
606 }
608 static char *
609 io_get(struct io *io, int c, bool can_read)
610 {
611 char *eol;
612 ssize_t readsize;
614 if (!io->buf) {
615 io->buf = io->bufpos = malloc(BUFSIZ);
616 if (!io->buf)
617 return NULL;
618 io->bufalloc = BUFSIZ;
619 io->bufsize = 0;
620 }
622 while (TRUE) {
623 if (io->bufsize > 0) {
624 eol = memchr(io->bufpos, c, io->bufsize);
625 if (eol) {
626 char *line = io->bufpos;
628 *eol = 0;
629 io->bufpos = eol + 1;
630 io->bufsize -= io->bufpos - line;
631 return line;
632 }
633 }
635 if (io_eof(io)) {
636 if (io->bufsize) {
637 io->bufpos[io->bufsize] = 0;
638 io->bufsize = 0;
639 return io->bufpos;
640 }
641 return NULL;
642 }
644 if (!can_read)
645 return NULL;
647 if (io->bufsize > 0 && io->bufpos > io->buf)
648 memmove(io->buf, io->bufpos, io->bufsize);
650 io->bufpos = io->buf;
651 readsize = io_read(io, io->buf + io->bufsize, io->bufalloc - io->bufsize);
652 if (io_error(io))
653 return NULL;
654 io->bufsize += readsize;
655 }
656 }
658 static bool
659 io_write(struct io *io, const void *buf, size_t bufsize)
660 {
661 size_t written = 0;
663 while (!io_error(io) && written < bufsize) {
664 ssize_t size;
666 size = write(io->pipe, buf + written, bufsize - written);
667 if (size < 0 && (errno == EAGAIN || errno == EINTR))
668 continue;
669 else if (size == -1)
670 io->error = errno;
671 else
672 written += size;
673 }
675 return written == bufsize;
676 }
678 static bool
679 io_read_buf(struct io *io, char buf[], size_t bufsize)
680 {
681 bool error;
683 io->buf = io->bufpos = buf;
684 io->bufalloc = bufsize;
685 error = !io_get(io, '\n', TRUE) && io_error(io);
686 io->buf = NULL;
688 return done_io(io) || error;
689 }
691 static bool
692 run_io_buf(const char **argv, char buf[], size_t bufsize)
693 {
694 struct io io = {};
696 return run_io_rd(&io, argv, FORMAT_NONE) && io_read_buf(&io, buf, bufsize);
697 }
699 static int
700 io_load(struct io *io, const char *separators,
701 int (*read_property)(char *, size_t, char *, size_t))
702 {
703 char *name;
704 int state = OK;
706 if (!start_io(io))
707 return ERR;
709 while (state == OK && (name = io_get(io, '\n', TRUE))) {
710 char *value;
711 size_t namelen;
712 size_t valuelen;
714 name = chomp_string(name);
715 namelen = strcspn(name, separators);
717 if (name[namelen]) {
718 name[namelen] = 0;
719 value = chomp_string(name + namelen + 1);
720 valuelen = strlen(value);
722 } else {
723 value = "";
724 valuelen = 0;
725 }
727 state = read_property(name, namelen, value, valuelen);
728 }
730 if (state != ERR && io_error(io))
731 state = ERR;
732 done_io(io);
734 return state;
735 }
737 static int
738 run_io_load(const char **argv, const char *separators,
739 int (*read_property)(char *, size_t, char *, size_t))
740 {
741 struct io io = {};
743 return init_io_rd(&io, argv, NULL, FORMAT_NONE)
744 ? io_load(&io, separators, read_property) : ERR;
745 }
748 /*
749 * User requests
750 */
752 #define REQ_INFO \
753 /* XXX: Keep the view request first and in sync with views[]. */ \
754 REQ_GROUP("View switching") \
755 REQ_(VIEW_MAIN, "Show main view"), \
756 REQ_(VIEW_DIFF, "Show diff view"), \
757 REQ_(VIEW_LOG, "Show log view"), \
758 REQ_(VIEW_TREE, "Show tree view"), \
759 REQ_(VIEW_BLOB, "Show blob view"), \
760 REQ_(VIEW_BLAME, "Show blame view"), \
761 REQ_(VIEW_HELP, "Show help page"), \
762 REQ_(VIEW_PAGER, "Show pager view"), \
763 REQ_(VIEW_STATUS, "Show status view"), \
764 REQ_(VIEW_STAGE, "Show stage view"), \
765 \
766 REQ_GROUP("View manipulation") \
767 REQ_(ENTER, "Enter current line and scroll"), \
768 REQ_(NEXT, "Move to next"), \
769 REQ_(PREVIOUS, "Move to previous"), \
770 REQ_(PARENT, "Move to parent"), \
771 REQ_(VIEW_NEXT, "Move focus to next view"), \
772 REQ_(REFRESH, "Reload and refresh"), \
773 REQ_(MAXIMIZE, "Maximize the current view"), \
774 REQ_(VIEW_CLOSE, "Close the current view"), \
775 REQ_(QUIT, "Close all views and quit"), \
776 \
777 REQ_GROUP("View specific requests") \
778 REQ_(STATUS_UPDATE, "Update file status"), \
779 REQ_(STATUS_REVERT, "Revert file changes"), \
780 REQ_(STATUS_MERGE, "Merge file using external tool"), \
781 REQ_(STAGE_NEXT, "Find next chunk to stage"), \
782 \
783 REQ_GROUP("Cursor navigation") \
784 REQ_(MOVE_UP, "Move cursor one line up"), \
785 REQ_(MOVE_DOWN, "Move cursor one line down"), \
786 REQ_(MOVE_PAGE_DOWN, "Move cursor one page down"), \
787 REQ_(MOVE_PAGE_UP, "Move cursor one page up"), \
788 REQ_(MOVE_FIRST_LINE, "Move cursor to first line"), \
789 REQ_(MOVE_LAST_LINE, "Move cursor to last line"), \
790 \
791 REQ_GROUP("Scrolling") \
792 REQ_(SCROLL_LEFT, "Scroll two columns left"), \
793 REQ_(SCROLL_RIGHT, "Scroll two columns right"), \
794 REQ_(SCROLL_LINE_UP, "Scroll one line up"), \
795 REQ_(SCROLL_LINE_DOWN, "Scroll one line down"), \
796 REQ_(SCROLL_PAGE_UP, "Scroll one page up"), \
797 REQ_(SCROLL_PAGE_DOWN, "Scroll one page down"), \
798 \
799 REQ_GROUP("Searching") \
800 REQ_(SEARCH, "Search the view"), \
801 REQ_(SEARCH_BACK, "Search backwards in the view"), \
802 REQ_(FIND_NEXT, "Find next search match"), \
803 REQ_(FIND_PREV, "Find previous search match"), \
804 \
805 REQ_GROUP("Option manipulation") \
806 REQ_(TOGGLE_LINENO, "Toggle line numbers"), \
807 REQ_(TOGGLE_DATE, "Toggle date display"), \
808 REQ_(TOGGLE_AUTHOR, "Toggle author display"), \
809 REQ_(TOGGLE_REV_GRAPH, "Toggle revision graph visualization"), \
810 REQ_(TOGGLE_REFS, "Toggle reference display (tags/branches)"), \
811 \
812 REQ_GROUP("Misc") \
813 REQ_(PROMPT, "Bring up the prompt"), \
814 REQ_(SCREEN_REDRAW, "Redraw the screen"), \
815 REQ_(SHOW_VERSION, "Show version information"), \
816 REQ_(STOP_LOADING, "Stop all loading views"), \
817 REQ_(EDIT, "Open in editor"), \
818 REQ_(NONE, "Do nothing")
821 /* User action requests. */
822 enum request {
823 #define REQ_GROUP(help)
824 #define REQ_(req, help) REQ_##req
826 /* Offset all requests to avoid conflicts with ncurses getch values. */
827 REQ_OFFSET = KEY_MAX + 1,
828 REQ_INFO
830 #undef REQ_GROUP
831 #undef REQ_
832 };
834 struct request_info {
835 enum request request;
836 const char *name;
837 int namelen;
838 const char *help;
839 };
841 static struct request_info req_info[] = {
842 #define REQ_GROUP(help) { 0, NULL, 0, (help) },
843 #define REQ_(req, help) { REQ_##req, (#req), STRING_SIZE(#req), (help) }
844 REQ_INFO
845 #undef REQ_GROUP
846 #undef REQ_
847 };
849 static enum request
850 get_request(const char *name)
851 {
852 int namelen = strlen(name);
853 int i;
855 for (i = 0; i < ARRAY_SIZE(req_info); i++)
856 if (req_info[i].namelen == namelen &&
857 !string_enum_compare(req_info[i].name, name, namelen))
858 return req_info[i].request;
860 return REQ_NONE;
861 }
864 /*
865 * Options
866 */
868 /* Option and state variables. */
869 static bool opt_date = TRUE;
870 static bool opt_author = TRUE;
871 static bool opt_line_number = FALSE;
872 static bool opt_line_graphics = TRUE;
873 static bool opt_rev_graph = FALSE;
874 static bool opt_show_refs = TRUE;
875 static int opt_num_interval = NUMBER_INTERVAL;
876 static int opt_tab_size = TAB_SIZE;
877 static int opt_author_cols = AUTHOR_COLS-1;
878 static char opt_path[SIZEOF_STR] = "";
879 static char opt_file[SIZEOF_STR] = "";
880 static char opt_ref[SIZEOF_REF] = "";
881 static char opt_head[SIZEOF_REF] = "";
882 static char opt_head_rev[SIZEOF_REV] = "";
883 static char opt_remote[SIZEOF_REF] = "";
884 static char opt_encoding[20] = "UTF-8";
885 static bool opt_utf8 = TRUE;
886 static char opt_codeset[20] = "UTF-8";
887 static iconv_t opt_iconv = ICONV_NONE;
888 static char opt_search[SIZEOF_STR] = "";
889 static char opt_cdup[SIZEOF_STR] = "";
890 static char opt_prefix[SIZEOF_STR] = "";
891 static char opt_git_dir[SIZEOF_STR] = "";
892 static signed char opt_is_inside_work_tree = -1; /* set to TRUE or FALSE */
893 static char opt_editor[SIZEOF_STR] = "";
894 static FILE *opt_tty = NULL;
896 #define is_initial_commit() (!*opt_head_rev)
897 #define is_head_commit(rev) (!strcmp((rev), "HEAD") || !strcmp(opt_head_rev, (rev)))
900 /*
901 * Line-oriented content detection.
902 */
904 #define LINE_INFO \
905 LINE(DIFF_HEADER, "diff --git ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
906 LINE(DIFF_CHUNK, "@@", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
907 LINE(DIFF_ADD, "+", COLOR_GREEN, COLOR_DEFAULT, 0), \
908 LINE(DIFF_DEL, "-", COLOR_RED, COLOR_DEFAULT, 0), \
909 LINE(DIFF_INDEX, "index ", COLOR_BLUE, COLOR_DEFAULT, 0), \
910 LINE(DIFF_OLDMODE, "old file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
911 LINE(DIFF_NEWMODE, "new file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
912 LINE(DIFF_COPY_FROM, "copy from", COLOR_YELLOW, COLOR_DEFAULT, 0), \
913 LINE(DIFF_COPY_TO, "copy to", COLOR_YELLOW, COLOR_DEFAULT, 0), \
914 LINE(DIFF_RENAME_FROM, "rename from", COLOR_YELLOW, COLOR_DEFAULT, 0), \
915 LINE(DIFF_RENAME_TO, "rename to", COLOR_YELLOW, COLOR_DEFAULT, 0), \
916 LINE(DIFF_SIMILARITY, "similarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
917 LINE(DIFF_DISSIMILARITY,"dissimilarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
918 LINE(DIFF_TREE, "diff-tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
919 LINE(PP_AUTHOR, "Author: ", COLOR_CYAN, COLOR_DEFAULT, 0), \
920 LINE(PP_COMMIT, "Commit: ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
921 LINE(PP_MERGE, "Merge: ", COLOR_BLUE, COLOR_DEFAULT, 0), \
922 LINE(PP_DATE, "Date: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
923 LINE(PP_ADATE, "AuthorDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
924 LINE(PP_CDATE, "CommitDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
925 LINE(PP_REFS, "Refs: ", COLOR_RED, COLOR_DEFAULT, 0), \
926 LINE(COMMIT, "commit ", COLOR_GREEN, COLOR_DEFAULT, 0), \
927 LINE(PARENT, "parent ", COLOR_BLUE, COLOR_DEFAULT, 0), \
928 LINE(TREE, "tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
929 LINE(AUTHOR, "author ", COLOR_GREEN, COLOR_DEFAULT, 0), \
930 LINE(COMMITTER, "committer ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
931 LINE(SIGNOFF, " Signed-off-by", COLOR_YELLOW, COLOR_DEFAULT, 0), \
932 LINE(ACKED, " Acked-by", COLOR_YELLOW, COLOR_DEFAULT, 0), \
933 LINE(DEFAULT, "", COLOR_DEFAULT, COLOR_DEFAULT, A_NORMAL), \
934 LINE(CURSOR, "", COLOR_WHITE, COLOR_GREEN, A_BOLD), \
935 LINE(STATUS, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
936 LINE(DELIMITER, "", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
937 LINE(DATE, "", COLOR_BLUE, COLOR_DEFAULT, 0), \
938 LINE(MODE, "", COLOR_CYAN, COLOR_DEFAULT, 0), \
939 LINE(LINE_NUMBER, "", COLOR_CYAN, COLOR_DEFAULT, 0), \
940 LINE(TITLE_BLUR, "", COLOR_WHITE, COLOR_BLUE, 0), \
941 LINE(TITLE_FOCUS, "", COLOR_WHITE, COLOR_BLUE, A_BOLD), \
942 LINE(MAIN_COMMIT, "", COLOR_DEFAULT, COLOR_DEFAULT, 0), \
943 LINE(MAIN_TAG, "", COLOR_MAGENTA, COLOR_DEFAULT, A_BOLD), \
944 LINE(MAIN_LOCAL_TAG,"", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
945 LINE(MAIN_REMOTE, "", COLOR_YELLOW, COLOR_DEFAULT, 0), \
946 LINE(MAIN_TRACKED, "", COLOR_YELLOW, COLOR_DEFAULT, A_BOLD), \
947 LINE(MAIN_REF, "", COLOR_CYAN, COLOR_DEFAULT, 0), \
948 LINE(MAIN_HEAD, "", COLOR_CYAN, COLOR_DEFAULT, A_BOLD), \
949 LINE(MAIN_REVGRAPH,"", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
950 LINE(TREE_HEAD, "", COLOR_DEFAULT, COLOR_DEFAULT, A_BOLD), \
951 LINE(TREE_DIR, "", COLOR_YELLOW, COLOR_DEFAULT, A_NORMAL), \
952 LINE(TREE_FILE, "", COLOR_DEFAULT, COLOR_DEFAULT, A_NORMAL), \
953 LINE(STAT_HEAD, "", COLOR_YELLOW, COLOR_DEFAULT, 0), \
954 LINE(STAT_SECTION, "", COLOR_CYAN, COLOR_DEFAULT, 0), \
955 LINE(STAT_NONE, "", COLOR_DEFAULT, COLOR_DEFAULT, 0), \
956 LINE(STAT_STAGED, "", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
957 LINE(STAT_UNSTAGED,"", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
958 LINE(STAT_UNTRACKED,"", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
959 LINE(BLAME_ID, "", COLOR_MAGENTA, COLOR_DEFAULT, 0)
961 enum line_type {
962 #define LINE(type, line, fg, bg, attr) \
963 LINE_##type
964 LINE_INFO,
965 LINE_NONE
966 #undef LINE
967 };
969 struct line_info {
970 const char *name; /* Option name. */
971 int namelen; /* Size of option name. */
972 const char *line; /* The start of line to match. */
973 int linelen; /* Size of string to match. */
974 int fg, bg, attr; /* Color and text attributes for the lines. */
975 };
977 static struct line_info line_info[] = {
978 #define LINE(type, line, fg, bg, attr) \
979 { #type, STRING_SIZE(#type), (line), STRING_SIZE(line), (fg), (bg), (attr) }
980 LINE_INFO
981 #undef LINE
982 };
984 static enum line_type
985 get_line_type(const char *line)
986 {
987 int linelen = strlen(line);
988 enum line_type type;
990 for (type = 0; type < ARRAY_SIZE(line_info); type++)
991 /* Case insensitive search matches Signed-off-by lines better. */
992 if (linelen >= line_info[type].linelen &&
993 !strncasecmp(line_info[type].line, line, line_info[type].linelen))
994 return type;
996 return LINE_DEFAULT;
997 }
999 static inline int
1000 get_line_attr(enum line_type type)
1001 {
1002 assert(type < ARRAY_SIZE(line_info));
1003 return COLOR_PAIR(type) | line_info[type].attr;
1004 }
1006 static struct line_info *
1007 get_line_info(const char *name)
1008 {
1009 size_t namelen = strlen(name);
1010 enum line_type type;
1012 for (type = 0; type < ARRAY_SIZE(line_info); type++)
1013 if (namelen == line_info[type].namelen &&
1014 !string_enum_compare(line_info[type].name, name, namelen))
1015 return &line_info[type];
1017 return NULL;
1018 }
1020 static void
1021 init_colors(void)
1022 {
1023 int default_bg = line_info[LINE_DEFAULT].bg;
1024 int default_fg = line_info[LINE_DEFAULT].fg;
1025 enum line_type type;
1027 start_color();
1029 if (assume_default_colors(default_fg, default_bg) == ERR) {
1030 default_bg = COLOR_BLACK;
1031 default_fg = COLOR_WHITE;
1032 }
1034 for (type = 0; type < ARRAY_SIZE(line_info); type++) {
1035 struct line_info *info = &line_info[type];
1036 int bg = info->bg == COLOR_DEFAULT ? default_bg : info->bg;
1037 int fg = info->fg == COLOR_DEFAULT ? default_fg : info->fg;
1039 init_pair(type, fg, bg);
1040 }
1041 }
1043 struct line {
1044 enum line_type type;
1046 /* State flags */
1047 unsigned int selected:1;
1048 unsigned int dirty:1;
1049 unsigned int cleareol:1;
1051 void *data; /* User data */
1052 };
1055 /*
1056 * Keys
1057 */
1059 struct keybinding {
1060 int alias;
1061 enum request request;
1062 };
1064 static struct keybinding default_keybindings[] = {
1065 /* View switching */
1066 { 'm', REQ_VIEW_MAIN },
1067 { 'd', REQ_VIEW_DIFF },
1068 { 'l', REQ_VIEW_LOG },
1069 { 't', REQ_VIEW_TREE },
1070 { 'f', REQ_VIEW_BLOB },
1071 { 'B', REQ_VIEW_BLAME },
1072 { 'p', REQ_VIEW_PAGER },
1073 { 'h', REQ_VIEW_HELP },
1074 { 'S', REQ_VIEW_STATUS },
1075 { 'c', REQ_VIEW_STAGE },
1077 /* View manipulation */
1078 { 'q', REQ_VIEW_CLOSE },
1079 { KEY_TAB, REQ_VIEW_NEXT },
1080 { KEY_RETURN, REQ_ENTER },
1081 { KEY_UP, REQ_PREVIOUS },
1082 { KEY_DOWN, REQ_NEXT },
1083 { 'R', REQ_REFRESH },
1084 { KEY_F(5), REQ_REFRESH },
1085 { 'O', REQ_MAXIMIZE },
1087 /* Cursor navigation */
1088 { 'k', REQ_MOVE_UP },
1089 { 'j', REQ_MOVE_DOWN },
1090 { KEY_HOME, REQ_MOVE_FIRST_LINE },
1091 { KEY_END, REQ_MOVE_LAST_LINE },
1092 { KEY_NPAGE, REQ_MOVE_PAGE_DOWN },
1093 { ' ', REQ_MOVE_PAGE_DOWN },
1094 { KEY_PPAGE, REQ_MOVE_PAGE_UP },
1095 { 'b', REQ_MOVE_PAGE_UP },
1096 { '-', REQ_MOVE_PAGE_UP },
1098 /* Scrolling */
1099 { KEY_LEFT, REQ_SCROLL_LEFT },
1100 { KEY_RIGHT, REQ_SCROLL_RIGHT },
1101 { KEY_IC, REQ_SCROLL_LINE_UP },
1102 { KEY_DC, REQ_SCROLL_LINE_DOWN },
1103 { 'w', REQ_SCROLL_PAGE_UP },
1104 { 's', REQ_SCROLL_PAGE_DOWN },
1106 /* Searching */
1107 { '/', REQ_SEARCH },
1108 { '?', REQ_SEARCH_BACK },
1109 { 'n', REQ_FIND_NEXT },
1110 { 'N', REQ_FIND_PREV },
1112 /* Misc */
1113 { 'Q', REQ_QUIT },
1114 { 'z', REQ_STOP_LOADING },
1115 { 'v', REQ_SHOW_VERSION },
1116 { 'r', REQ_SCREEN_REDRAW },
1117 { '.', REQ_TOGGLE_LINENO },
1118 { 'D', REQ_TOGGLE_DATE },
1119 { 'A', REQ_TOGGLE_AUTHOR },
1120 { 'g', REQ_TOGGLE_REV_GRAPH },
1121 { 'F', REQ_TOGGLE_REFS },
1122 { ':', REQ_PROMPT },
1123 { 'u', REQ_STATUS_UPDATE },
1124 { '!', REQ_STATUS_REVERT },
1125 { 'M', REQ_STATUS_MERGE },
1126 { '@', REQ_STAGE_NEXT },
1127 { ',', REQ_PARENT },
1128 { 'e', REQ_EDIT },
1129 };
1131 #define KEYMAP_INFO \
1132 KEYMAP_(GENERIC), \
1133 KEYMAP_(MAIN), \
1134 KEYMAP_(DIFF), \
1135 KEYMAP_(LOG), \
1136 KEYMAP_(TREE), \
1137 KEYMAP_(BLOB), \
1138 KEYMAP_(BLAME), \
1139 KEYMAP_(PAGER), \
1140 KEYMAP_(HELP), \
1141 KEYMAP_(STATUS), \
1142 KEYMAP_(STAGE)
1144 enum keymap {
1145 #define KEYMAP_(name) KEYMAP_##name
1146 KEYMAP_INFO
1147 #undef KEYMAP_
1148 };
1150 static struct enum_map keymap_table[] = {
1151 #define KEYMAP_(name) ENUM_MAP(#name, KEYMAP_##name)
1152 KEYMAP_INFO
1153 #undef KEYMAP_
1154 };
1156 #define set_keymap(map, name) map_enum(map, keymap_table, name)
1158 struct keybinding_table {
1159 struct keybinding *data;
1160 size_t size;
1161 };
1163 static struct keybinding_table keybindings[ARRAY_SIZE(keymap_table)];
1165 static void
1166 add_keybinding(enum keymap keymap, enum request request, int key)
1167 {
1168 struct keybinding_table *table = &keybindings[keymap];
1170 table->data = realloc(table->data, (table->size + 1) * sizeof(*table->data));
1171 if (!table->data)
1172 die("Failed to allocate keybinding");
1173 table->data[table->size].alias = key;
1174 table->data[table->size++].request = request;
1175 }
1177 /* Looks for a key binding first in the given map, then in the generic map, and
1178 * lastly in the default keybindings. */
1179 static enum request
1180 get_keybinding(enum keymap keymap, int key)
1181 {
1182 size_t i;
1184 for (i = 0; i < keybindings[keymap].size; i++)
1185 if (keybindings[keymap].data[i].alias == key)
1186 return keybindings[keymap].data[i].request;
1188 for (i = 0; i < keybindings[KEYMAP_GENERIC].size; i++)
1189 if (keybindings[KEYMAP_GENERIC].data[i].alias == key)
1190 return keybindings[KEYMAP_GENERIC].data[i].request;
1192 for (i = 0; i < ARRAY_SIZE(default_keybindings); i++)
1193 if (default_keybindings[i].alias == key)
1194 return default_keybindings[i].request;
1196 return (enum request) key;
1197 }
1200 struct key {
1201 const char *name;
1202 int value;
1203 };
1205 static struct key key_table[] = {
1206 { "Enter", KEY_RETURN },
1207 { "Space", ' ' },
1208 { "Backspace", KEY_BACKSPACE },
1209 { "Tab", KEY_TAB },
1210 { "Escape", KEY_ESC },
1211 { "Left", KEY_LEFT },
1212 { "Right", KEY_RIGHT },
1213 { "Up", KEY_UP },
1214 { "Down", KEY_DOWN },
1215 { "Insert", KEY_IC },
1216 { "Delete", KEY_DC },
1217 { "Hash", '#' },
1218 { "Home", KEY_HOME },
1219 { "End", KEY_END },
1220 { "PageUp", KEY_PPAGE },
1221 { "PageDown", KEY_NPAGE },
1222 { "F1", KEY_F(1) },
1223 { "F2", KEY_F(2) },
1224 { "F3", KEY_F(3) },
1225 { "F4", KEY_F(4) },
1226 { "F5", KEY_F(5) },
1227 { "F6", KEY_F(6) },
1228 { "F7", KEY_F(7) },
1229 { "F8", KEY_F(8) },
1230 { "F9", KEY_F(9) },
1231 { "F10", KEY_F(10) },
1232 { "F11", KEY_F(11) },
1233 { "F12", KEY_F(12) },
1234 };
1236 static int
1237 get_key_value(const char *name)
1238 {
1239 int i;
1241 for (i = 0; i < ARRAY_SIZE(key_table); i++)
1242 if (!strcasecmp(key_table[i].name, name))
1243 return key_table[i].value;
1245 if (strlen(name) == 1 && isprint(*name))
1246 return (int) *name;
1248 return ERR;
1249 }
1251 static const char *
1252 get_key_name(int key_value)
1253 {
1254 static char key_char[] = "'X'";
1255 const char *seq = NULL;
1256 int key;
1258 for (key = 0; key < ARRAY_SIZE(key_table); key++)
1259 if (key_table[key].value == key_value)
1260 seq = key_table[key].name;
1262 if (seq == NULL &&
1263 key_value < 127 &&
1264 isprint(key_value)) {
1265 key_char[1] = (char) key_value;
1266 seq = key_char;
1267 }
1269 return seq ? seq : "(no key)";
1270 }
1272 static const char *
1273 get_key(enum request request)
1274 {
1275 static char buf[BUFSIZ];
1276 size_t pos = 0;
1277 char *sep = "";
1278 int i;
1280 buf[pos] = 0;
1282 for (i = 0; i < ARRAY_SIZE(default_keybindings); i++) {
1283 struct keybinding *keybinding = &default_keybindings[i];
1285 if (keybinding->request != request)
1286 continue;
1288 if (!string_format_from(buf, &pos, "%s%s", sep,
1289 get_key_name(keybinding->alias)))
1290 return "Too many keybindings!";
1291 sep = ", ";
1292 }
1294 return buf;
1295 }
1297 struct run_request {
1298 enum keymap keymap;
1299 int key;
1300 const char *argv[SIZEOF_ARG];
1301 };
1303 static struct run_request *run_request;
1304 static size_t run_requests;
1306 static enum request
1307 add_run_request(enum keymap keymap, int key, int argc, const char **argv)
1308 {
1309 struct run_request *req;
1311 if (argc >= ARRAY_SIZE(req->argv) - 1)
1312 return REQ_NONE;
1314 req = realloc(run_request, (run_requests + 1) * sizeof(*run_request));
1315 if (!req)
1316 return REQ_NONE;
1318 run_request = req;
1319 req = &run_request[run_requests];
1320 req->keymap = keymap;
1321 req->key = key;
1322 req->argv[0] = NULL;
1324 if (!format_argv(req->argv, argv, FORMAT_NONE))
1325 return REQ_NONE;
1327 return REQ_NONE + ++run_requests;
1328 }
1330 static struct run_request *
1331 get_run_request(enum request request)
1332 {
1333 if (request <= REQ_NONE)
1334 return NULL;
1335 return &run_request[request - REQ_NONE - 1];
1336 }
1338 static void
1339 add_builtin_run_requests(void)
1340 {
1341 const char *cherry_pick[] = { "git", "cherry-pick", "%(commit)", NULL };
1342 const char *gc[] = { "git", "gc", NULL };
1343 struct {
1344 enum keymap keymap;
1345 int key;
1346 int argc;
1347 const char **argv;
1348 } reqs[] = {
1349 { KEYMAP_MAIN, 'C', ARRAY_SIZE(cherry_pick) - 1, cherry_pick },
1350 { KEYMAP_GENERIC, 'G', ARRAY_SIZE(gc) - 1, gc },
1351 };
1352 int i;
1354 for (i = 0; i < ARRAY_SIZE(reqs); i++) {
1355 enum request req;
1357 req = add_run_request(reqs[i].keymap, reqs[i].key, reqs[i].argc, reqs[i].argv);
1358 if (req != REQ_NONE)
1359 add_keybinding(reqs[i].keymap, req, reqs[i].key);
1360 }
1361 }
1363 /*
1364 * User config file handling.
1365 */
1367 static int config_lineno;
1368 static bool config_errors;
1369 static const char *config_msg;
1371 static struct enum_map color_map[] = {
1372 #define COLOR_MAP(name) ENUM_MAP(#name, COLOR_##name)
1373 COLOR_MAP(DEFAULT),
1374 COLOR_MAP(BLACK),
1375 COLOR_MAP(BLUE),
1376 COLOR_MAP(CYAN),
1377 COLOR_MAP(GREEN),
1378 COLOR_MAP(MAGENTA),
1379 COLOR_MAP(RED),
1380 COLOR_MAP(WHITE),
1381 COLOR_MAP(YELLOW),
1382 };
1384 static struct enum_map attr_map[] = {
1385 #define ATTR_MAP(name) ENUM_MAP(#name, A_##name)
1386 ATTR_MAP(NORMAL),
1387 ATTR_MAP(BLINK),
1388 ATTR_MAP(BOLD),
1389 ATTR_MAP(DIM),
1390 ATTR_MAP(REVERSE),
1391 ATTR_MAP(STANDOUT),
1392 ATTR_MAP(UNDERLINE),
1393 };
1395 #define set_attribute(attr, name) map_enum(attr, attr_map, name)
1397 static int
1398 parse_int(int *opt, const char *arg, int min, int max)
1399 {
1400 int value = atoi(arg);
1402 if (min <= value && value <= max) {
1403 *opt = value;
1404 return OK;
1405 }
1407 config_msg = "Integer value out of bound";
1408 return ERR;
1409 }
1411 static bool
1412 set_color(int *color, const char *name)
1413 {
1414 if (map_enum(color, color_map, name))
1415 return TRUE;
1416 if (!prefixcmp(name, "color"))
1417 return parse_int(color, name + 5, 0, 255) == OK;
1418 return FALSE;
1419 }
1421 /* Wants: object fgcolor bgcolor [attribute] */
1422 static int
1423 option_color_command(int argc, const char *argv[])
1424 {
1425 struct line_info *info;
1427 if (argc != 3 && argc != 4) {
1428 config_msg = "Wrong number of arguments given to color command";
1429 return ERR;
1430 }
1432 info = get_line_info(argv[0]);
1433 if (!info) {
1434 static struct enum_map obsolete[] = {
1435 ENUM_MAP("main-delim", LINE_DELIMITER),
1436 ENUM_MAP("main-date", LINE_DATE),
1437 ENUM_MAP("main-author", LINE_AUTHOR),
1438 };
1439 int index;
1441 if (!map_enum(&index, obsolete, argv[0])) {
1442 config_msg = "Unknown color name";
1443 return ERR;
1444 }
1445 info = &line_info[index];
1446 }
1448 if (!set_color(&info->fg, argv[1]) ||
1449 !set_color(&info->bg, argv[2])) {
1450 config_msg = "Unknown color";
1451 return ERR;
1452 }
1454 if (argc == 4 && !set_attribute(&info->attr, argv[3])) {
1455 config_msg = "Unknown attribute";
1456 return ERR;
1457 }
1459 return OK;
1460 }
1462 static int parse_bool(bool *opt, const char *arg)
1463 {
1464 *opt = (!strcmp(arg, "1") || !strcmp(arg, "true") || !strcmp(arg, "yes"))
1465 ? TRUE : FALSE;
1466 return OK;
1467 }
1469 static int
1470 parse_string(char *opt, const char *arg, size_t optsize)
1471 {
1472 int arglen = strlen(arg);
1474 switch (arg[0]) {
1475 case '\"':
1476 case '\'':
1477 if (arglen == 1 || arg[arglen - 1] != arg[0]) {
1478 config_msg = "Unmatched quotation";
1479 return ERR;
1480 }
1481 arg += 1; arglen -= 2;
1482 default:
1483 string_ncopy_do(opt, optsize, arg, strlen(arg));
1484 return OK;
1485 }
1486 }
1488 /* Wants: name = value */
1489 static int
1490 option_set_command(int argc, const char *argv[])
1491 {
1492 if (argc != 3) {
1493 config_msg = "Wrong number of arguments given to set command";
1494 return ERR;
1495 }
1497 if (strcmp(argv[1], "=")) {
1498 config_msg = "No value assigned";
1499 return ERR;
1500 }
1502 if (!strcmp(argv[0], "show-author"))
1503 return parse_bool(&opt_author, argv[2]);
1505 if (!strcmp(argv[0], "show-date"))
1506 return parse_bool(&opt_date, argv[2]);
1508 if (!strcmp(argv[0], "show-rev-graph"))
1509 return parse_bool(&opt_rev_graph, argv[2]);
1511 if (!strcmp(argv[0], "show-refs"))
1512 return parse_bool(&opt_show_refs, argv[2]);
1514 if (!strcmp(argv[0], "show-line-numbers"))
1515 return parse_bool(&opt_line_number, argv[2]);
1517 if (!strcmp(argv[0], "line-graphics"))
1518 return parse_bool(&opt_line_graphics, argv[2]);
1520 if (!strcmp(argv[0], "line-number-interval"))
1521 return parse_int(&opt_num_interval, argv[2], 1, 1024);
1523 if (!strcmp(argv[0], "author-width"))
1524 return parse_int(&opt_author_cols, argv[2], 0, 1024);
1526 if (!strcmp(argv[0], "tab-size"))
1527 return parse_int(&opt_tab_size, argv[2], 1, 1024);
1529 if (!strcmp(argv[0], "commit-encoding"))
1530 return parse_string(opt_encoding, argv[2], sizeof(opt_encoding));
1532 config_msg = "Unknown variable name";
1533 return ERR;
1534 }
1536 /* Wants: mode request key */
1537 static int
1538 option_bind_command(int argc, const char *argv[])
1539 {
1540 enum request request;
1541 int keymap;
1542 int key;
1544 if (argc < 3) {
1545 config_msg = "Wrong number of arguments given to bind command";
1546 return ERR;
1547 }
1549 if (set_keymap(&keymap, argv[0]) == ERR) {
1550 config_msg = "Unknown key map";
1551 return ERR;
1552 }
1554 key = get_key_value(argv[1]);
1555 if (key == ERR) {
1556 config_msg = "Unknown key";
1557 return ERR;
1558 }
1560 request = get_request(argv[2]);
1561 if (request == REQ_NONE) {
1562 static struct enum_map obsolete[] = {
1563 ENUM_MAP("cherry-pick", REQ_NONE),
1564 ENUM_MAP("screen-resize", REQ_NONE),
1565 ENUM_MAP("tree-parent", REQ_PARENT),
1566 };
1567 int alias;
1569 if (map_enum(&alias, obsolete, argv[2])) {
1570 if (alias != REQ_NONE)
1571 add_keybinding(keymap, alias, key);
1572 config_msg = "Obsolete request name";
1573 return ERR;
1574 }
1575 }
1576 if (request == REQ_NONE && *argv[2]++ == '!')
1577 request = add_run_request(keymap, key, argc - 2, argv + 2);
1578 if (request == REQ_NONE) {
1579 config_msg = "Unknown request name";
1580 return ERR;
1581 }
1583 add_keybinding(keymap, request, key);
1585 return OK;
1586 }
1588 static int
1589 set_option(const char *opt, char *value)
1590 {
1591 const char *argv[SIZEOF_ARG];
1592 int argc = 0;
1594 if (!argv_from_string(argv, &argc, value)) {
1595 config_msg = "Too many option arguments";
1596 return ERR;
1597 }
1599 if (!strcmp(opt, "color"))
1600 return option_color_command(argc, argv);
1602 if (!strcmp(opt, "set"))
1603 return option_set_command(argc, argv);
1605 if (!strcmp(opt, "bind"))
1606 return option_bind_command(argc, argv);
1608 config_msg = "Unknown option command";
1609 return ERR;
1610 }
1612 static int
1613 read_option(char *opt, size_t optlen, char *value, size_t valuelen)
1614 {
1615 int status = OK;
1617 config_lineno++;
1618 config_msg = "Internal error";
1620 /* Check for comment markers, since read_properties() will
1621 * only ensure opt and value are split at first " \t". */
1622 optlen = strcspn(opt, "#");
1623 if (optlen == 0)
1624 return OK;
1626 if (opt[optlen] != 0) {
1627 config_msg = "No option value";
1628 status = ERR;
1630 } else {
1631 /* Look for comment endings in the value. */
1632 size_t len = strcspn(value, "#");
1634 if (len < valuelen) {
1635 valuelen = len;
1636 value[valuelen] = 0;
1637 }
1639 status = set_option(opt, value);
1640 }
1642 if (status == ERR) {
1643 warn("Error on line %d, near '%.*s': %s",
1644 config_lineno, (int) optlen, opt, config_msg);
1645 config_errors = TRUE;
1646 }
1648 /* Always keep going if errors are encountered. */
1649 return OK;
1650 }
1652 static void
1653 load_option_file(const char *path)
1654 {
1655 struct io io = {};
1657 /* It's OK that the file doesn't exist. */
1658 if (!io_open(&io, path))
1659 return;
1661 config_lineno = 0;
1662 config_errors = FALSE;
1664 if (io_load(&io, " \t", read_option) == ERR ||
1665 config_errors == TRUE)
1666 warn("Errors while loading %s.", path);
1667 }
1669 static int
1670 load_options(void)
1671 {
1672 const char *home = getenv("HOME");
1673 const char *tigrc_user = getenv("TIGRC_USER");
1674 const char *tigrc_system = getenv("TIGRC_SYSTEM");
1675 char buf[SIZEOF_STR];
1677 add_builtin_run_requests();
1679 if (!tigrc_system)
1680 tigrc_system = SYSCONFDIR "/tigrc";
1681 load_option_file(tigrc_system);
1683 if (!tigrc_user) {
1684 if (!home || !string_format(buf, "%s/.tigrc", home))
1685 return ERR;
1686 tigrc_user = buf;
1687 }
1688 load_option_file(tigrc_user);
1690 return OK;
1691 }
1694 /*
1695 * The viewer
1696 */
1698 struct view;
1699 struct view_ops;
1701 /* The display array of active views and the index of the current view. */
1702 static struct view *display[2];
1703 static unsigned int current_view;
1705 #define foreach_displayed_view(view, i) \
1706 for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
1708 #define displayed_views() (display[1] != NULL ? 2 : 1)
1710 /* Current head and commit ID */
1711 static char ref_blob[SIZEOF_REF] = "";
1712 static char ref_commit[SIZEOF_REF] = "HEAD";
1713 static char ref_head[SIZEOF_REF] = "HEAD";
1715 struct view {
1716 const char *name; /* View name */
1717 const char *cmd_env; /* Command line set via environment */
1718 const char *id; /* Points to either of ref_{head,commit,blob} */
1720 struct view_ops *ops; /* View operations */
1722 enum keymap keymap; /* What keymap does this view have */
1723 bool git_dir; /* Whether the view requires a git directory. */
1725 char ref[SIZEOF_REF]; /* Hovered commit reference */
1726 char vid[SIZEOF_REF]; /* View ID. Set to id member when updating. */
1728 int height, width; /* The width and height of the main window */
1729 WINDOW *win; /* The main window */
1730 WINDOW *title; /* The title window living below the main window */
1732 /* Navigation */
1733 unsigned long offset; /* Offset of the window top */
1734 unsigned long yoffset; /* Offset from the window side. */
1735 unsigned long lineno; /* Current line number */
1736 unsigned long p_offset; /* Previous offset of the window top */
1737 unsigned long p_yoffset;/* Previous offset from the window side */
1738 unsigned long p_lineno; /* Previous current line number */
1739 bool p_restore; /* Should the previous position be restored. */
1741 /* Searching */
1742 char grep[SIZEOF_STR]; /* Search string */
1743 regex_t *regex; /* Pre-compiled regexp */
1745 /* If non-NULL, points to the view that opened this view. If this view
1746 * is closed tig will switch back to the parent view. */
1747 struct view *parent;
1749 /* Buffering */
1750 size_t lines; /* Total number of lines */
1751 struct line *line; /* Line index */
1752 size_t line_alloc; /* Total number of allocated lines */
1753 unsigned int digits; /* Number of digits in the lines member. */
1755 /* Drawing */
1756 struct line *curline; /* Line currently being drawn. */
1757 enum line_type curtype; /* Attribute currently used for drawing. */
1758 unsigned long col; /* Column when drawing. */
1759 bool has_scrolled; /* View was scrolled. */
1760 bool can_hscroll; /* View can be scrolled horizontally. */
1762 /* Loading */
1763 struct io io;
1764 struct io *pipe;
1765 time_t start_time;
1766 time_t update_secs;
1767 };
1769 struct view_ops {
1770 /* What type of content being displayed. Used in the title bar. */
1771 const char *type;
1772 /* Default command arguments. */
1773 const char **argv;
1774 /* Open and reads in all view content. */
1775 bool (*open)(struct view *view);
1776 /* Read one line; updates view->line. */
1777 bool (*read)(struct view *view, char *data);
1778 /* Draw one line; @lineno must be < view->height. */
1779 bool (*draw)(struct view *view, struct line *line, unsigned int lineno);
1780 /* Depending on view handle a special requests. */
1781 enum request (*request)(struct view *view, enum request request, struct line *line);
1782 /* Search for regexp in a line. */
1783 bool (*grep)(struct view *view, struct line *line);
1784 /* Select line */
1785 void (*select)(struct view *view, struct line *line);
1786 };
1788 static struct view_ops blame_ops;
1789 static struct view_ops blob_ops;
1790 static struct view_ops diff_ops;
1791 static struct view_ops help_ops;
1792 static struct view_ops log_ops;
1793 static struct view_ops main_ops;
1794 static struct view_ops pager_ops;
1795 static struct view_ops stage_ops;
1796 static struct view_ops status_ops;
1797 static struct view_ops tree_ops;
1799 #define VIEW_STR(name, env, ref, ops, map, git) \
1800 { name, #env, ref, ops, map, git }
1802 #define VIEW_(id, name, ops, git, ref) \
1803 VIEW_STR(name, TIG_##id##_CMD, ref, ops, KEYMAP_##id, git)
1806 static struct view views[] = {
1807 VIEW_(MAIN, "main", &main_ops, TRUE, ref_head),
1808 VIEW_(DIFF, "diff", &diff_ops, TRUE, ref_commit),
1809 VIEW_(LOG, "log", &log_ops, TRUE, ref_head),
1810 VIEW_(TREE, "tree", &tree_ops, TRUE, ref_commit),
1811 VIEW_(BLOB, "blob", &blob_ops, TRUE, ref_blob),
1812 VIEW_(BLAME, "blame", &blame_ops, TRUE, ref_commit),
1813 VIEW_(HELP, "help", &help_ops, FALSE, ""),
1814 VIEW_(PAGER, "pager", &pager_ops, FALSE, "stdin"),
1815 VIEW_(STATUS, "status", &status_ops, TRUE, ""),
1816 VIEW_(STAGE, "stage", &stage_ops, TRUE, ""),
1817 };
1819 #define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
1820 #define VIEW_REQ(view) ((view) - views + REQ_OFFSET + 1)
1822 #define foreach_view(view, i) \
1823 for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
1825 #define view_is_displayed(view) \
1826 (view == display[0] || view == display[1])
1829 enum line_graphic {
1830 LINE_GRAPHIC_VLINE
1831 };
1833 static int line_graphics[] = {
1834 /* LINE_GRAPHIC_VLINE: */ '|'
1835 };
1837 static inline void
1838 set_view_attr(struct view *view, enum line_type type)
1839 {
1840 if (!view->curline->selected && view->curtype != type) {
1841 wattrset(view->win, get_line_attr(type));
1842 wchgat(view->win, -1, 0, type, NULL);
1843 view->curtype = type;
1844 }
1845 }
1847 static int
1848 draw_chars(struct view *view, enum line_type type, const char *string,
1849 int max_len, bool use_tilde)
1850 {
1851 int len = 0;
1852 int col = 0;
1853 int trimmed = FALSE;
1854 size_t skip = view->yoffset > view->col ? view->yoffset - view->col : 0;
1856 if (max_len <= 0)
1857 return 0;
1859 if (opt_utf8) {
1860 len = utf8_length(&string, skip, &col, max_len, &trimmed, use_tilde);
1861 } else {
1862 col = len = strlen(string);
1863 if (len > max_len) {
1864 if (use_tilde) {
1865 max_len -= 1;
1866 }
1867 col = len = max_len;
1868 trimmed = TRUE;
1869 }
1870 }
1872 set_view_attr(view, type);
1873 if (len > 0)
1874 waddnstr(view->win, string, len);
1875 if (trimmed && use_tilde) {
1876 set_view_attr(view, LINE_DELIMITER);
1877 waddch(view->win, '~');
1878 col++;
1879 }
1881 if (view->col + col >= view->width + view->yoffset)
1882 view->can_hscroll = TRUE;
1884 return col;
1885 }
1887 static int
1888 draw_space(struct view *view, enum line_type type, int max, int spaces)
1889 {
1890 static char space[] = " ";
1891 int col = 0;
1893 spaces = MIN(max, spaces);
1895 while (spaces > 0) {
1896 int len = MIN(spaces, sizeof(space) - 1);
1898 col += draw_chars(view, type, space, spaces, FALSE);
1899 spaces -= len;
1900 }
1902 return col;
1903 }
1905 static bool
1906 draw_lineno(struct view *view, unsigned int lineno)
1907 {
1908 size_t skip = view->yoffset > view->col ? view->yoffset - view->col : 0;
1909 char number[10];
1910 int digits3 = view->digits < 3 ? 3 : view->digits;
1911 int max_number = MIN(digits3, STRING_SIZE(number));
1912 int max = view->width - view->col;
1913 int col;
1915 if (max < max_number)
1916 max_number = max;
1918 lineno += view->offset + 1;
1919 if (lineno == 1 || (lineno % opt_num_interval) == 0) {
1920 static char fmt[] = "%1ld";
1922 if (view->digits <= 9)
1923 fmt[1] = '0' + digits3;
1925 if (!string_format(number, fmt, lineno))
1926 number[0] = 0;
1927 col = draw_chars(view, LINE_LINE_NUMBER, number, max_number, TRUE);
1928 } else {
1929 col = draw_space(view, LINE_LINE_NUMBER, max_number, max_number);
1930 }
1932 if (col < max && skip <= col) {
1933 set_view_attr(view, LINE_DEFAULT);
1934 waddch(view->win, line_graphics[LINE_GRAPHIC_VLINE]);
1935 }
1936 col++;
1938 view->col += col;
1939 if (col < max && skip <= col)
1940 col = draw_space(view, LINE_DEFAULT, max - col, 1);
1941 view->col++;
1943 return view->width + view->yoffset <= view->col;
1944 }
1946 static bool
1947 draw_text(struct view *view, enum line_type type, const char *string, bool trim)
1948 {
1949 view->col += draw_chars(view, type, string, view->width + view->yoffset - view->col, trim);
1950 return view->width - view->col <= 0;
1951 }
1953 static bool
1954 draw_graphic(struct view *view, enum line_type type, chtype graphic[], size_t size)
1955 {
1956 size_t skip = view->yoffset > view->col ? view->yoffset - view->col : 0;
1957 int max = view->width - view->col;
1958 int i;
1960 if (max < size)
1961 size = max;
1963 set_view_attr(view, type);
1964 /* Using waddch() instead of waddnstr() ensures that
1965 * they'll be rendered correctly for the cursor line. */
1966 for (i = skip; i < size; i++)
1967 waddch(view->win, graphic[i]);
1969 view->col += size;
1970 if (size < max && skip <= size)
1971 waddch(view->win, ' ');
1972 view->col++;
1974 return view->width - view->col <= 0;
1975 }
1977 static bool
1978 draw_field(struct view *view, enum line_type type, const char *text, int len, bool trim)
1979 {
1980 int max = MIN(view->width - view->col, len);
1981 int col;
1983 if (text)
1984 col = draw_chars(view, type, text, max - 1, trim);
1985 else
1986 col = draw_space(view, type, max - 1, max - 1);
1988 view->col += col;
1989 view->col += draw_space(view, LINE_DEFAULT, max - col, max - col);
1990 return view->width + view->yoffset <= view->col;
1991 }
1993 static bool
1994 draw_date(struct view *view, struct tm *time)
1995 {
1996 char buf[DATE_COLS];
1997 char *date;
1998 int timelen = 0;
2000 if (time)
2001 timelen = strftime(buf, sizeof(buf), DATE_FORMAT, time);
2002 date = timelen ? buf : NULL;
2004 return draw_field(view, LINE_DATE, date, DATE_COLS, FALSE);
2005 }
2007 static bool
2008 draw_author(struct view *view, const char *author)
2009 {
2010 bool trim = opt_author_cols == 0 || opt_author_cols > 5 || !author;
2012 if (!trim) {
2013 static char initials[10];
2014 size_t pos;
2016 #define is_initial_sep(c) (isspace(c) || ispunct(c) || (c) == '@')
2018 memset(initials, 0, sizeof(initials));
2019 for (pos = 0; *author && pos < opt_author_cols - 1; author++, pos++) {
2020 while (is_initial_sep(*author))
2021 author++;
2022 strncpy(&initials[pos], author, sizeof(initials) - 1 - pos);
2023 while (*author && !is_initial_sep(author[1]))
2024 author++;
2025 }
2027 author = initials;
2028 }
2030 return draw_field(view, LINE_AUTHOR, author, opt_author_cols, trim);
2031 }
2033 static bool
2034 draw_mode(struct view *view, mode_t mode)
2035 {
2036 static const char dir_mode[] = "drwxr-xr-x";
2037 static const char link_mode[] = "lrwxrwxrwx";
2038 static const char exe_mode[] = "-rwxr-xr-x";
2039 static const char file_mode[] = "-rw-r--r--";
2040 const char *str;
2042 if (S_ISDIR(mode))
2043 str = dir_mode;
2044 else if (S_ISLNK(mode))
2045 str = link_mode;
2046 else if (mode & S_IXUSR)
2047 str = exe_mode;
2048 else
2049 str = file_mode;
2051 return draw_field(view, LINE_MODE, str, sizeof(file_mode), FALSE);
2052 }
2054 static bool
2055 draw_view_line(struct view *view, unsigned int lineno)
2056 {
2057 struct line *line;
2058 bool selected = (view->offset + lineno == view->lineno);
2060 assert(view_is_displayed(view));
2062 if (view->offset + lineno >= view->lines)
2063 return FALSE;
2065 line = &view->line[view->offset + lineno];
2067 wmove(view->win, lineno, 0);
2068 if (line->cleareol)
2069 wclrtoeol(view->win);
2070 view->col = 0;
2071 view->curline = line;
2072 view->curtype = LINE_NONE;
2073 line->selected = FALSE;
2074 line->dirty = line->cleareol = 0;
2076 if (selected) {
2077 set_view_attr(view, LINE_CURSOR);
2078 line->selected = TRUE;
2079 view->ops->select(view, line);
2080 }
2082 return view->ops->draw(view, line, lineno);
2083 }
2085 static void
2086 redraw_view_dirty(struct view *view)
2087 {
2088 bool dirty = FALSE;
2089 int lineno;
2091 for (lineno = 0; lineno < view->height; lineno++) {
2092 if (view->offset + lineno >= view->lines)
2093 break;
2094 if (!view->line[view->offset + lineno].dirty)
2095 continue;
2096 dirty = TRUE;
2097 if (!draw_view_line(view, lineno))
2098 break;
2099 }
2101 if (!dirty)
2102 return;
2103 wnoutrefresh(view->win);
2104 }
2106 static void
2107 redraw_view_from(struct view *view, int lineno)
2108 {
2109 assert(0 <= lineno && lineno < view->height);
2111 if (lineno == 0)
2112 view->can_hscroll = FALSE;
2114 for (; lineno < view->height; lineno++) {
2115 if (!draw_view_line(view, lineno))
2116 break;
2117 }
2119 wnoutrefresh(view->win);
2120 }
2122 static void
2123 redraw_view(struct view *view)
2124 {
2125 werase(view->win);
2126 redraw_view_from(view, 0);
2127 }
2130 static void
2131 update_view_title(struct view *view)
2132 {
2133 char buf[SIZEOF_STR];
2134 char state[SIZEOF_STR];
2135 size_t bufpos = 0, statelen = 0;
2137 assert(view_is_displayed(view));
2139 if (view != VIEW(REQ_VIEW_STATUS) && view->lines) {
2140 unsigned int view_lines = view->offset + view->height;
2141 unsigned int lines = view->lines
2142 ? MIN(view_lines, view->lines) * 100 / view->lines
2143 : 0;
2145 string_format_from(state, &statelen, " - %s %d of %d (%d%%)",
2146 view->ops->type,
2147 view->lineno + 1,
2148 view->lines,
2149 lines);
2151 }
2153 if (view->pipe) {
2154 time_t secs = time(NULL) - view->start_time;
2156 /* Three git seconds are a long time ... */
2157 if (secs > 2)
2158 string_format_from(state, &statelen, " loading %lds", secs);
2159 }
2161 string_format_from(buf, &bufpos, "[%s]", view->name);
2162 if (*view->ref && bufpos < view->width) {
2163 size_t refsize = strlen(view->ref);
2164 size_t minsize = bufpos + 1 + /* abbrev= */ 7 + 1 + statelen;
2166 if (minsize < view->width)
2167 refsize = view->width - minsize + 7;
2168 string_format_from(buf, &bufpos, " %.*s", (int) refsize, view->ref);
2169 }
2171 if (statelen && bufpos < view->width) {
2172 string_format_from(buf, &bufpos, "%s", state);
2173 }
2175 if (view == display[current_view])
2176 wbkgdset(view->title, get_line_attr(LINE_TITLE_FOCUS));
2177 else
2178 wbkgdset(view->title, get_line_attr(LINE_TITLE_BLUR));
2180 mvwaddnstr(view->title, 0, 0, buf, bufpos);
2181 wclrtoeol(view->title);
2182 wnoutrefresh(view->title);
2183 }
2185 static void
2186 resize_display(void)
2187 {
2188 int offset, i;
2189 struct view *base = display[0];
2190 struct view *view = display[1] ? display[1] : display[0];
2192 /* Setup window dimensions */
2194 getmaxyx(stdscr, base->height, base->width);
2196 /* Make room for the status window. */
2197 base->height -= 1;
2199 if (view != base) {
2200 /* Horizontal split. */
2201 view->width = base->width;
2202 view->height = SCALE_SPLIT_VIEW(base->height);
2203 base->height -= view->height;
2205 /* Make room for the title bar. */
2206 view->height -= 1;
2207 }
2209 /* Make room for the title bar. */
2210 base->height -= 1;
2212 offset = 0;
2214 foreach_displayed_view (view, i) {
2215 if (!view->win) {
2216 view->win = newwin(view->height, 0, offset, 0);
2217 if (!view->win)
2218 die("Failed to create %s view", view->name);
2220 scrollok(view->win, FALSE);
2222 view->title = newwin(1, 0, offset + view->height, 0);
2223 if (!view->title)
2224 die("Failed to create title window");
2226 } else {
2227 wresize(view->win, view->height, view->width);
2228 mvwin(view->win, offset, 0);
2229 mvwin(view->title, offset + view->height, 0);
2230 }
2232 offset += view->height + 1;
2233 }
2234 }
2236 static void
2237 redraw_display(bool clear)
2238 {
2239 struct view *view;
2240 int i;
2242 foreach_displayed_view (view, i) {
2243 if (clear)
2244 wclear(view->win);
2245 redraw_view(view);
2246 update_view_title(view);
2247 }
2248 }
2250 static void
2251 toggle_view_option(bool *option, const char *help)
2252 {
2253 *option = !*option;
2254 redraw_display(FALSE);
2255 report("%sabling %s", *option ? "En" : "Dis", help);
2256 }
2258 /*
2259 * Navigation
2260 */
2262 /* Scrolling backend */
2263 static void
2264 do_scroll_view(struct view *view, int lines)
2265 {
2266 bool redraw_current_line = FALSE;
2268 /* The rendering expects the new offset. */
2269 view->offset += lines;
2271 assert(0 <= view->offset && view->offset < view->lines);
2272 assert(lines);
2274 /* Move current line into the view. */
2275 if (view->lineno < view->offset) {
2276 view->lineno = view->offset;
2277 redraw_current_line = TRUE;
2278 } else if (view->lineno >= view->offset + view->height) {
2279 view->lineno = view->offset + view->height - 1;
2280 redraw_current_line = TRUE;
2281 }
2283 assert(view->offset <= view->lineno && view->lineno < view->lines);
2285 /* Redraw the whole screen if scrolling is pointless. */
2286 if (view->height < ABS(lines)) {
2287 redraw_view(view);
2289 } else {
2290 int line = lines > 0 ? view->height - lines : 0;
2291 int end = line + ABS(lines);
2293 scrollok(view->win, TRUE);
2294 wscrl(view->win, lines);
2295 scrollok(view->win, FALSE);
2297 while (line < end && draw_view_line(view, line))
2298 line++;
2300 if (redraw_current_line)
2301 draw_view_line(view, view->lineno - view->offset);
2302 wnoutrefresh(view->win);
2303 }
2305 view->has_scrolled = TRUE;
2306 report("");
2307 }
2309 /* Scroll frontend */
2310 static void
2311 scroll_view(struct view *view, enum request request)
2312 {
2313 int lines = 1;
2315 assert(view_is_displayed(view));
2317 switch (request) {
2318 case REQ_SCROLL_LEFT:
2319 if (view->yoffset == 0) {
2320 report("Cannot scroll beyond the first column");
2321 return;
2322 }
2323 if (view->yoffset <= SCROLL_INTERVAL)
2324 view->yoffset = 0;
2325 else
2326 view->yoffset -= SCROLL_INTERVAL;
2327 redraw_view_from(view, 0);
2328 report("");
2329 return;
2330 case REQ_SCROLL_RIGHT:
2331 if (!view->can_hscroll) {
2332 report("Cannot scroll beyond the last column");
2333 return;
2334 }
2335 view->yoffset += SCROLL_INTERVAL;
2336 redraw_view(view);
2337 report("");
2338 return;
2339 case REQ_SCROLL_PAGE_DOWN:
2340 lines = view->height;
2341 case REQ_SCROLL_LINE_DOWN:
2342 if (view->offset + lines > view->lines)
2343 lines = view->lines - view->offset;
2345 if (lines == 0 || view->offset + view->height >= view->lines) {
2346 report("Cannot scroll beyond the last line");
2347 return;
2348 }
2349 break;
2351 case REQ_SCROLL_PAGE_UP:
2352 lines = view->height;
2353 case REQ_SCROLL_LINE_UP:
2354 if (lines > view->offset)
2355 lines = view->offset;
2357 if (lines == 0) {
2358 report("Cannot scroll beyond the first line");
2359 return;
2360 }
2362 lines = -lines;
2363 break;
2365 default:
2366 die("request %d not handled in switch", request);
2367 }
2369 do_scroll_view(view, lines);
2370 }
2372 /* Cursor moving */
2373 static void
2374 move_view(struct view *view, enum request request)
2375 {
2376 int scroll_steps = 0;
2377 int steps;
2379 switch (request) {
2380 case REQ_MOVE_FIRST_LINE:
2381 steps = -view->lineno;
2382 break;
2384 case REQ_MOVE_LAST_LINE:
2385 steps = view->lines - view->lineno - 1;
2386 break;
2388 case REQ_MOVE_PAGE_UP:
2389 steps = view->height > view->lineno
2390 ? -view->lineno : -view->height;
2391 break;
2393 case REQ_MOVE_PAGE_DOWN:
2394 steps = view->lineno + view->height >= view->lines
2395 ? view->lines - view->lineno - 1 : view->height;
2396 break;
2398 case REQ_MOVE_UP:
2399 steps = -1;
2400 break;
2402 case REQ_MOVE_DOWN:
2403 steps = 1;
2404 break;
2406 default:
2407 die("request %d not handled in switch", request);
2408 }
2410 if (steps <= 0 && view->lineno == 0) {
2411 report("Cannot move beyond the first line");
2412 return;
2414 } else if (steps >= 0 && view->lineno + 1 >= view->lines) {
2415 report("Cannot move beyond the last line");
2416 return;
2417 }
2419 /* Move the current line */
2420 view->lineno += steps;
2421 assert(0 <= view->lineno && view->lineno < view->lines);
2423 /* Check whether the view needs to be scrolled */
2424 if (view->lineno < view->offset ||
2425 view->lineno >= view->offset + view->height) {
2426 scroll_steps = steps;
2427 if (steps < 0 && -steps > view->offset) {
2428 scroll_steps = -view->offset;
2430 } else if (steps > 0) {
2431 if (view->lineno == view->lines - 1 &&
2432 view->lines > view->height) {
2433 scroll_steps = view->lines - view->offset - 1;
2434 if (scroll_steps >= view->height)
2435 scroll_steps -= view->height - 1;
2436 }
2437 }
2438 }
2440 if (!view_is_displayed(view)) {
2441 view->offset += scroll_steps;
2442 assert(0 <= view->offset && view->offset < view->lines);
2443 view->ops->select(view, &view->line[view->lineno]);
2444 return;
2445 }
2447 /* Repaint the old "current" line if we be scrolling */
2448 if (ABS(steps) < view->height)
2449 draw_view_line(view, view->lineno - steps - view->offset);
2451 if (scroll_steps) {
2452 do_scroll_view(view, scroll_steps);
2453 return;
2454 }
2456 /* Draw the current line */
2457 draw_view_line(view, view->lineno - view->offset);
2459 wnoutrefresh(view->win);
2460 report("");
2461 }
2464 /*
2465 * Searching
2466 */
2468 static void search_view(struct view *view, enum request request);
2470 static void
2471 select_view_line(struct view *view, unsigned long lineno)
2472 {
2473 if (lineno - view->offset >= view->height) {
2474 view->offset = lineno;
2475 view->lineno = lineno;
2476 if (view_is_displayed(view))
2477 redraw_view(view);
2479 } else {
2480 unsigned long old_lineno = view->lineno - view->offset;
2482 view->lineno = lineno;
2483 if (view_is_displayed(view)) {
2484 draw_view_line(view, old_lineno);
2485 draw_view_line(view, view->lineno - view->offset);
2486 wnoutrefresh(view->win);
2487 } else {
2488 view->ops->select(view, &view->line[view->lineno]);
2489 }
2490 }
2491 }
2493 static void
2494 find_next(struct view *view, enum request request)
2495 {
2496 unsigned long lineno = view->lineno;
2497 int direction;
2499 if (!*view->grep) {
2500 if (!*opt_search)
2501 report("No previous search");
2502 else
2503 search_view(view, request);
2504 return;
2505 }
2507 switch (request) {
2508 case REQ_SEARCH:
2509 case REQ_FIND_NEXT:
2510 direction = 1;
2511 break;
2513 case REQ_SEARCH_BACK:
2514 case REQ_FIND_PREV:
2515 direction = -1;
2516 break;
2518 default:
2519 return;
2520 }
2522 if (request == REQ_FIND_NEXT || request == REQ_FIND_PREV)
2523 lineno += direction;
2525 /* Note, lineno is unsigned long so will wrap around in which case it
2526 * will become bigger than view->lines. */
2527 for (; lineno < view->lines; lineno += direction) {
2528 if (view->ops->grep(view, &view->line[lineno])) {
2529 select_view_line(view, lineno);
2530 report("Line %ld matches '%s'", lineno + 1, view->grep);
2531 return;
2532 }
2533 }
2535 report("No match found for '%s'", view->grep);
2536 }
2538 static void
2539 search_view(struct view *view, enum request request)
2540 {
2541 int regex_err;
2543 if (view->regex) {
2544 regfree(view->regex);
2545 *view->grep = 0;
2546 } else {
2547 view->regex = calloc(1, sizeof(*view->regex));
2548 if (!view->regex)
2549 return;
2550 }
2552 regex_err = regcomp(view->regex, opt_search, REG_EXTENDED);
2553 if (regex_err != 0) {
2554 char buf[SIZEOF_STR] = "unknown error";
2556 regerror(regex_err, view->regex, buf, sizeof(buf));
2557 report("Search failed: %s", buf);
2558 return;
2559 }
2561 string_copy(view->grep, opt_search);
2563 find_next(view, request);
2564 }
2566 /*
2567 * Incremental updating
2568 */
2570 static void
2571 reset_view(struct view *view)
2572 {
2573 int i;
2575 for (i = 0; i < view->lines; i++)
2576 free(view->line[i].data);
2577 free(view->line);
2579 view->p_offset = view->offset;
2580 view->p_yoffset = view->yoffset;
2581 view->p_lineno = view->lineno;
2583 view->line = NULL;
2584 view->offset = 0;
2585 view->yoffset = 0;
2586 view->lines = 0;
2587 view->lineno = 0;
2588 view->line_alloc = 0;
2589 view->vid[0] = 0;
2590 view->update_secs = 0;
2591 }
2593 static void
2594 free_argv(const char *argv[])
2595 {
2596 int argc;
2598 for (argc = 0; argv[argc]; argc++)
2599 free((void *) argv[argc]);
2600 }
2602 static bool
2603 format_argv(const char *dst_argv[], const char *src_argv[], enum format_flags flags)
2604 {
2605 char buf[SIZEOF_STR];
2606 int argc;
2607 bool noreplace = flags == FORMAT_NONE;
2609 free_argv(dst_argv);
2611 for (argc = 0; src_argv[argc]; argc++) {
2612 const char *arg = src_argv[argc];
2613 size_t bufpos = 0;
2615 while (arg) {
2616 char *next = strstr(arg, "%(");
2617 int len = next - arg;
2618 const char *value;
2620 if (!next || noreplace) {
2621 if (flags == FORMAT_DASH && !strcmp(arg, "--"))
2622 noreplace = TRUE;
2623 len = strlen(arg);
2624 value = "";
2626 } else if (!prefixcmp(next, "%(directory)")) {
2627 value = opt_path;
2629 } else if (!prefixcmp(next, "%(file)")) {
2630 value = opt_file;
2632 } else if (!prefixcmp(next, "%(ref)")) {
2633 value = *opt_ref ? opt_ref : "HEAD";
2635 } else if (!prefixcmp(next, "%(head)")) {
2636 value = ref_head;
2638 } else if (!prefixcmp(next, "%(commit)")) {
2639 value = ref_commit;
2641 } else if (!prefixcmp(next, "%(blob)")) {
2642 value = ref_blob;
2644 } else {
2645 report("Unknown replacement: `%s`", next);
2646 return FALSE;
2647 }
2649 if (!string_format_from(buf, &bufpos, "%.*s%s", len, arg, value))
2650 return FALSE;
2652 arg = next && !noreplace ? strchr(next, ')') + 1 : NULL;
2653 }
2655 dst_argv[argc] = strdup(buf);
2656 if (!dst_argv[argc])
2657 break;
2658 }
2660 dst_argv[argc] = NULL;
2662 return src_argv[argc] == NULL;
2663 }
2665 static bool
2666 restore_view_position(struct view *view)
2667 {
2668 if (!view->p_restore || (view->pipe && view->lines <= view->p_lineno))
2669 return FALSE;
2671 /* Changing the view position cancels the restoring. */
2672 /* FIXME: Changing back to the first line is not detected. */
2673 if (view->offset != 0 || view->lineno != 0) {
2674 view->p_restore = FALSE;
2675 return FALSE;
2676 }
2678 if (view->p_lineno >= view->lines) {
2679 view->p_lineno = view->lines > 0 ? view->lines - 1 : 0;
2680 if (view->p_offset >= view->p_lineno) {
2681 unsigned long half = view->height / 2;
2683 if (view->p_lineno > half)
2684 view->p_offset = view->p_lineno - half;
2685 else
2686 view->p_offset = 0;
2687 }
2688 }
2690 if (view_is_displayed(view) &&
2691 view->offset != view->p_offset &&
2692 view->lineno != view->p_lineno)
2693 werase(view->win);
2695 view->offset = view->p_offset;
2696 view->yoffset = view->p_yoffset;
2697 view->lineno = view->p_lineno;
2698 view->p_restore = FALSE;
2700 return TRUE;
2701 }
2703 static void
2704 end_update(struct view *view, bool force)
2705 {
2706 if (!view->pipe)
2707 return;
2708 while (!view->ops->read(view, NULL))
2709 if (!force)
2710 return;
2711 set_nonblocking_input(FALSE);
2712 if (force)
2713 kill_io(view->pipe);
2714 done_io(view->pipe);
2715 view->pipe = NULL;
2716 }
2718 static void
2719 setup_update(struct view *view, const char *vid)
2720 {
2721 set_nonblocking_input(TRUE);
2722 reset_view(view);
2723 string_copy_rev(view->vid, vid);
2724 view->pipe = &view->io;
2725 view->start_time = time(NULL);
2726 }
2728 static bool
2729 prepare_update(struct view *view, const char *argv[], const char *dir,
2730 enum format_flags flags)
2731 {
2732 if (view->pipe)
2733 end_update(view, TRUE);
2734 return init_io_rd(&view->io, argv, dir, flags);
2735 }
2737 static bool
2738 prepare_update_file(struct view *view, const char *name)
2739 {
2740 if (view->pipe)
2741 end_update(view, TRUE);
2742 return io_open(&view->io, name);
2743 }
2745 static bool
2746 begin_update(struct view *view, bool refresh)
2747 {
2748 if (view->pipe)
2749 end_update(view, TRUE);
2751 if (refresh) {
2752 if (!start_io(&view->io))
2753 return FALSE;
2755 } else {
2756 if (view == VIEW(REQ_VIEW_TREE) && strcmp(view->vid, view->id))
2757 opt_path[0] = 0;
2759 if (!run_io_rd(&view->io, view->ops->argv, FORMAT_ALL))
2760 return FALSE;
2762 /* Put the current ref_* value to the view title ref
2763 * member. This is needed by the blob view. Most other
2764 * views sets it automatically after loading because the
2765 * first line is a commit line. */
2766 string_copy_rev(view->ref, view->id);
2767 }
2769 setup_update(view, view->id);
2771 return TRUE;
2772 }
2774 #define ITEM_CHUNK_SIZE 256
2775 static void *
2776 realloc_items(void *mem, size_t *size, size_t new_size, size_t item_size)
2777 {
2778 size_t num_chunks = *size / ITEM_CHUNK_SIZE;
2779 size_t num_chunks_new = (new_size + ITEM_CHUNK_SIZE - 1) / ITEM_CHUNK_SIZE;
2781 if (mem == NULL || num_chunks != num_chunks_new) {
2782 *size = num_chunks_new * ITEM_CHUNK_SIZE;
2783 mem = realloc(mem, *size * item_size);
2784 }
2786 return mem;
2787 }
2789 static struct line *
2790 realloc_lines(struct view *view, size_t line_size)
2791 {
2792 size_t alloc = view->line_alloc;
2793 struct line *tmp = realloc_items(view->line, &alloc, line_size,
2794 sizeof(*view->line));
2796 if (!tmp)
2797 return NULL;
2799 view->line = tmp;
2800 view->line_alloc = alloc;
2801 return view->line;
2802 }
2804 static bool
2805 update_view(struct view *view)
2806 {
2807 char out_buffer[BUFSIZ * 2];
2808 char *line;
2809 /* Clear the view and redraw everything since the tree sorting
2810 * might have rearranged things. */
2811 bool redraw = view->lines == 0;
2812 bool can_read = TRUE;
2814 if (!view->pipe)
2815 return TRUE;
2817 if (!io_can_read(view->pipe)) {
2818 if (view->lines == 0) {
2819 time_t secs = time(NULL) - view->start_time;
2821 if (secs > 1 && secs > view->update_secs) {
2822 if (view->update_secs == 0)
2823 redraw_view(view);
2824 update_view_title(view);
2825 view->update_secs = secs;
2826 }
2827 }
2828 return TRUE;
2829 }
2831 for (; (line = io_get(view->pipe, '\n', can_read)); can_read = FALSE) {
2832 if (opt_iconv != ICONV_NONE) {
2833 ICONV_CONST char *inbuf = line;
2834 size_t inlen = strlen(line) + 1;
2836 char *outbuf = out_buffer;
2837 size_t outlen = sizeof(out_buffer);
2839 size_t ret;
2841 ret = iconv(opt_iconv, &inbuf, &inlen, &outbuf, &outlen);
2842 if (ret != (size_t) -1)
2843 line = out_buffer;
2844 }
2846 if (!view->ops->read(view, line)) {
2847 report("Allocation failure");
2848 end_update(view, TRUE);
2849 return FALSE;
2850 }
2851 }
2853 {
2854 unsigned long lines = view->lines;
2855 int digits;
2857 for (digits = 0; lines; digits++)
2858 lines /= 10;
2860 /* Keep the displayed view in sync with line number scaling. */
2861 if (digits != view->digits) {
2862 view->digits = digits;
2863 if (opt_line_number || view == VIEW(REQ_VIEW_BLAME))
2864 redraw = TRUE;
2865 }
2866 }
2868 if (io_error(view->pipe)) {
2869 report("Failed to read: %s", io_strerror(view->pipe));
2870 end_update(view, TRUE);
2872 } else if (io_eof(view->pipe)) {
2873 report("");
2874 end_update(view, FALSE);
2875 }
2877 if (restore_view_position(view))
2878 redraw = TRUE;
2880 if (!view_is_displayed(view))
2881 return TRUE;
2883 if (redraw)
2884 redraw_view_from(view, 0);
2885 else
2886 redraw_view_dirty(view);
2888 /* Update the title _after_ the redraw so that if the redraw picks up a
2889 * commit reference in view->ref it'll be available here. */
2890 update_view_title(view);
2891 return TRUE;
2892 }
2894 static struct line *
2895 add_line_data(struct view *view, void *data, enum line_type type)
2896 {
2897 struct line *line;
2899 if (!realloc_lines(view, view->lines + 1))
2900 return NULL;
2902 line = &view->line[view->lines++];
2903 memset(line, 0, sizeof(*line));
2904 line->type = type;
2905 line->data = data;
2906 line->dirty = 1;
2908 return line;
2909 }
2911 static struct line *
2912 add_line_text(struct view *view, const char *text, enum line_type type)
2913 {
2914 char *data = text ? strdup(text) : NULL;
2916 return data ? add_line_data(view, data, type) : NULL;
2917 }
2919 static struct line *
2920 add_line_format(struct view *view, enum line_type type, const char *fmt, ...)
2921 {
2922 char buf[SIZEOF_STR];
2923 va_list args;
2925 va_start(args, fmt);
2926 if (vsnprintf(buf, sizeof(buf), fmt, args) >= sizeof(buf))
2927 buf[0] = 0;
2928 va_end(args);
2930 return buf[0] ? add_line_text(view, buf, type) : NULL;
2931 }
2933 /*
2934 * View opening
2935 */
2937 enum open_flags {
2938 OPEN_DEFAULT = 0, /* Use default view switching. */
2939 OPEN_SPLIT = 1, /* Split current view. */
2940 OPEN_RELOAD = 4, /* Reload view even if it is the current. */
2941 OPEN_REFRESH = 16, /* Refresh view using previous command. */
2942 OPEN_PREPARED = 32, /* Open already prepared command. */
2943 };
2945 static void
2946 open_view(struct view *prev, enum request request, enum open_flags flags)
2947 {
2948 bool split = !!(flags & OPEN_SPLIT);
2949 bool reload = !!(flags & (OPEN_RELOAD | OPEN_REFRESH | OPEN_PREPARED));
2950 bool nomaximize = !!(flags & OPEN_REFRESH);
2951 struct view *view = VIEW(request);
2952 int nviews = displayed_views();
2953 struct view *base_view = display[0];
2955 if (view == prev && nviews == 1 && !reload) {
2956 report("Already in %s view", view->name);
2957 return;
2958 }
2960 if (view->git_dir && !opt_git_dir[0]) {
2961 report("The %s view is disabled in pager view", view->name);
2962 return;
2963 }
2965 if (split) {
2966 display[1] = view;
2967 current_view = 1;
2968 } else if (!nomaximize) {
2969 /* Maximize the current view. */
2970 memset(display, 0, sizeof(display));
2971 current_view = 0;
2972 display[current_view] = view;
2973 }
2975 /* Resize the view when switching between split- and full-screen,
2976 * or when switching between two different full-screen views. */
2977 if (nviews != displayed_views() ||
2978 (nviews == 1 && base_view != display[0]))
2979 resize_display();
2981 if (view->ops->open) {
2982 if (view->pipe)
2983 end_update(view, TRUE);
2984 if (!view->ops->open(view)) {
2985 report("Failed to load %s view", view->name);
2986 return;
2987 }
2988 restore_view_position(view);
2990 } else if ((reload || strcmp(view->vid, view->id)) &&
2991 !begin_update(view, flags & (OPEN_REFRESH | OPEN_PREPARED))) {
2992 report("Failed to load %s view", view->name);
2993 return;
2994 }
2996 if (split && prev->lineno - prev->offset >= prev->height) {
2997 /* Take the title line into account. */
2998 int lines = prev->lineno - prev->offset - prev->height + 1;
3000 /* Scroll the view that was split if the current line is
3001 * outside the new limited view. */
3002 do_scroll_view(prev, lines);
3003 }
3005 if (prev && view != prev) {
3006 if (split) {
3007 /* "Blur" the previous view. */
3008 update_view_title(prev);
3009 }
3011 view->parent = prev;
3012 }
3014 if (view->pipe && view->lines == 0) {
3015 /* Clear the old view and let the incremental updating refill
3016 * the screen. */
3017 werase(view->win);
3018 view->p_restore = flags & (OPEN_RELOAD | OPEN_REFRESH);
3019 report("");
3020 } else if (view_is_displayed(view)) {
3021 redraw_view(view);
3022 report("");
3023 }
3024 }
3026 static void
3027 open_external_viewer(const char *argv[], const char *dir)
3028 {
3029 def_prog_mode(); /* save current tty modes */
3030 endwin(); /* restore original tty modes */
3031 run_io_fg(argv, dir);
3032 fprintf(stderr, "Press Enter to continue");
3033 getc(opt_tty);
3034 reset_prog_mode();
3035 redraw_display(TRUE);
3036 }
3038 static void
3039 open_mergetool(const char *file)
3040 {
3041 const char *mergetool_argv[] = { "git", "mergetool", file, NULL };
3043 open_external_viewer(mergetool_argv, opt_cdup);
3044 }
3046 static void
3047 open_editor(bool from_root, const char *file)
3048 {
3049 const char *editor_argv[] = { "vi", file, NULL };
3050 const char *editor;
3052 editor = getenv("GIT_EDITOR");
3053 if (!editor && *opt_editor)
3054 editor = opt_editor;
3055 if (!editor)
3056 editor = getenv("VISUAL");
3057 if (!editor)
3058 editor = getenv("EDITOR");
3059 if (!editor)
3060 editor = "vi";
3062 editor_argv[0] = editor;
3063 open_external_viewer(editor_argv, from_root ? opt_cdup : NULL);
3064 }
3066 static void
3067 open_run_request(enum request request)
3068 {
3069 struct run_request *req = get_run_request(request);
3070 const char *argv[ARRAY_SIZE(req->argv)] = { NULL };
3072 if (!req) {
3073 report("Unknown run request");
3074 return;
3075 }
3077 if (format_argv(argv, req->argv, FORMAT_ALL))
3078 open_external_viewer(argv, NULL);
3079 free_argv(argv);
3080 }
3082 /*
3083 * User request switch noodle
3084 */
3086 static int
3087 view_driver(struct view *view, enum request request)
3088 {
3089 int i;
3091 if (request == REQ_NONE) {
3092 doupdate();
3093 return TRUE;
3094 }
3096 if (request > REQ_NONE) {
3097 open_run_request(request);
3098 /* FIXME: When all views can refresh always do this. */
3099 if (view == VIEW(REQ_VIEW_STATUS) ||
3100 view == VIEW(REQ_VIEW_MAIN) ||
3101 view == VIEW(REQ_VIEW_LOG) ||
3102 view == VIEW(REQ_VIEW_STAGE))
3103 request = REQ_REFRESH;
3104 else
3105 return TRUE;
3106 }
3108 if (view && view->lines) {
3109 request = view->ops->request(view, request, &view->line[view->lineno]);
3110 if (request == REQ_NONE)
3111 return TRUE;
3112 }
3114 switch (request) {
3115 case REQ_MOVE_UP:
3116 case REQ_MOVE_DOWN:
3117 case REQ_MOVE_PAGE_UP:
3118 case REQ_MOVE_PAGE_DOWN:
3119 case REQ_MOVE_FIRST_LINE:
3120 case REQ_MOVE_LAST_LINE:
3121 move_view(view, request);
3122 break;
3124 case REQ_SCROLL_LEFT:
3125 case REQ_SCROLL_RIGHT:
3126 case REQ_SCROLL_LINE_DOWN:
3127 case REQ_SCROLL_LINE_UP:
3128 case REQ_SCROLL_PAGE_DOWN:
3129 case REQ_SCROLL_PAGE_UP:
3130 scroll_view(view, request);
3131 break;
3133 case REQ_VIEW_BLAME:
3134 if (!opt_file[0]) {
3135 report("No file chosen, press %s to open tree view",
3136 get_key(REQ_VIEW_TREE));
3137 break;
3138 }
3139 open_view(view, request, OPEN_DEFAULT);
3140 break;
3142 case REQ_VIEW_BLOB:
3143 if (!ref_blob[0]) {
3144 report("No file chosen, press %s to open tree view",
3145 get_key(REQ_VIEW_TREE));
3146 break;
3147 }
3148 open_view(view, request, OPEN_DEFAULT);
3149 break;
3151 case REQ_VIEW_PAGER:
3152 if (!VIEW(REQ_VIEW_PAGER)->pipe && !VIEW(REQ_VIEW_PAGER)->lines) {
3153 report("No pager content, press %s to run command from prompt",
3154 get_key(REQ_PROMPT));
3155 break;
3156 }
3157 open_view(view, request, OPEN_DEFAULT);
3158 break;
3160 case REQ_VIEW_STAGE:
3161 if (!VIEW(REQ_VIEW_STAGE)->lines) {
3162 report("No stage content, press %s to open the status view and choose file",
3163 get_key(REQ_VIEW_STATUS));
3164 break;
3165 }
3166 open_view(view, request, OPEN_DEFAULT);
3167 break;
3169 case REQ_VIEW_STATUS:
3170 if (opt_is_inside_work_tree == FALSE) {
3171 report("The status view requires a working tree");
3172 break;
3173 }
3174 open_view(view, request, OPEN_DEFAULT);
3175 break;
3177 case REQ_VIEW_MAIN:
3178 case REQ_VIEW_DIFF:
3179 case REQ_VIEW_LOG:
3180 case REQ_VIEW_TREE:
3181 case REQ_VIEW_HELP:
3182 open_view(view, request, OPEN_DEFAULT);
3183 break;
3185 case REQ_NEXT:
3186 case REQ_PREVIOUS:
3187 request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
3189 if ((view == VIEW(REQ_VIEW_DIFF) &&
3190 view->parent == VIEW(REQ_VIEW_MAIN)) ||
3191 (view == VIEW(REQ_VIEW_DIFF) &&
3192 view->parent == VIEW(REQ_VIEW_BLAME)) ||
3193 (view == VIEW(REQ_VIEW_STAGE) &&
3194 view->parent == VIEW(REQ_VIEW_STATUS)) ||
3195 (view == VIEW(REQ_VIEW_BLOB) &&
3196 view->parent == VIEW(REQ_VIEW_TREE))) {
3197 int line;
3199 view = view->parent;
3200 line = view->lineno;
3201 move_view(view, request);
3202 if (view_is_displayed(view))
3203 update_view_title(view);
3204 if (line != view->lineno)
3205 view->ops->request(view, REQ_ENTER,
3206 &view->line[view->lineno]);
3208 } else {
3209 move_view(view, request);
3210 }
3211 break;
3213 case REQ_VIEW_NEXT:
3214 {
3215 int nviews = displayed_views();
3216 int next_view = (current_view + 1) % nviews;
3218 if (next_view == current_view) {
3219 report("Only one view is displayed");
3220 break;
3221 }
3223 current_view = next_view;
3224 /* Blur out the title of the previous view. */
3225 update_view_title(view);
3226 report("");
3227 break;
3228 }
3229 case REQ_REFRESH:
3230 report("Refreshing is not yet supported for the %s view", view->name);
3231 break;
3233 case REQ_MAXIMIZE:
3234 if (displayed_views() == 2)
3235 open_view(view, VIEW_REQ(view), OPEN_DEFAULT);
3236 break;
3238 case REQ_TOGGLE_LINENO:
3239 toggle_view_option(&opt_line_number, "line numbers");
3240 break;
3242 case REQ_TOGGLE_DATE:
3243 toggle_view_option(&opt_date, "date display");
3244 break;
3246 case REQ_TOGGLE_AUTHOR:
3247 toggle_view_option(&opt_author, "author display");
3248 break;
3250 case REQ_TOGGLE_REV_GRAPH:
3251 toggle_view_option(&opt_rev_graph, "revision graph display");
3252 break;
3254 case REQ_TOGGLE_REFS:
3255 toggle_view_option(&opt_show_refs, "reference display");
3256 break;
3258 case REQ_SEARCH:
3259 case REQ_SEARCH_BACK:
3260 search_view(view, request);
3261 break;
3263 case REQ_FIND_NEXT:
3264 case REQ_FIND_PREV:
3265 find_next(view, request);
3266 break;
3268 case REQ_STOP_LOADING:
3269 for (i = 0; i < ARRAY_SIZE(views); i++) {
3270 view = &views[i];
3271 if (view->pipe)
3272 report("Stopped loading the %s view", view->name),
3273 end_update(view, TRUE);
3274 }
3275 break;
3277 case REQ_SHOW_VERSION:
3278 report("tig-%s (built %s)", TIG_VERSION, __DATE__);
3279 return TRUE;
3281 case REQ_SCREEN_REDRAW:
3282 redraw_display(TRUE);
3283 break;
3285 case REQ_EDIT:
3286 report("Nothing to edit");
3287 break;
3289 case REQ_ENTER:
3290 report("Nothing to enter");
3291 break;
3293 case REQ_VIEW_CLOSE:
3294 /* XXX: Mark closed views by letting view->parent point to the
3295 * view itself. Parents to closed view should never be
3296 * followed. */
3297 if (view->parent &&
3298 view->parent->parent != view->parent) {
3299 memset(display, 0, sizeof(display));
3300 current_view = 0;
3301 display[current_view] = view->parent;
3302 view->parent = view;
3303 resize_display();
3304 redraw_display(FALSE);
3305 report("");
3306 break;
3307 }
3308 /* Fall-through */
3309 case REQ_QUIT:
3310 return FALSE;
3312 default:
3313 report("Unknown key, press 'h' for help");
3314 return TRUE;
3315 }
3317 return TRUE;
3318 }
3321 /*
3322 * View backend utilities
3323 */
3325 static void
3326 parse_timezone(time_t *time, const char *zone)
3327 {
3328 long tz;
3330 tz = ('0' - zone[1]) * 60 * 60 * 10;
3331 tz += ('0' - zone[2]) * 60 * 60;
3332 tz += ('0' - zone[3]) * 60;
3333 tz += ('0' - zone[4]);
3335 if (zone[0] == '-')
3336 tz = -tz;
3338 *time -= tz;
3339 }
3341 /* Parse author lines where the name may be empty:
3342 * author <email@address.tld> 1138474660 +0100
3343 */
3344 static void
3345 parse_author_line(char *ident, char *author, size_t authorsize, struct tm *tm)
3346 {
3347 char *nameend = strchr(ident, '<');
3348 char *emailend = strchr(ident, '>');
3350 if (nameend && emailend)
3351 *nameend = *emailend = 0;
3352 ident = chomp_string(ident);
3353 if (!*ident) {
3354 if (nameend)
3355 ident = chomp_string(nameend + 1);
3356 if (!*ident)
3357 ident = "Unknown";
3358 }
3360 string_ncopy_do(author, authorsize, ident, strlen(ident));
3362 /* Parse epoch and timezone */
3363 if (emailend && emailend[1] == ' ') {
3364 char *secs = emailend + 2;
3365 char *zone = strchr(secs, ' ');
3366 time_t time = (time_t) atol(secs);
3368 if (zone && strlen(zone) == STRING_SIZE(" +0700"))
3369 parse_timezone(&time, zone + 1);
3371 gmtime_r(&time, tm);
3372 }
3373 }
3375 static enum input_status
3376 select_commit_parent_handler(void *data, char *buf, int c)
3377 {
3378 size_t parents = *(size_t *) data;
3379 int parent = 0;
3381 if (!isdigit(c))
3382 return INPUT_SKIP;
3384 if (*buf)
3385 parent = atoi(buf) * 10;
3386 parent += c - '0';
3388 if (parent > parents)
3389 return INPUT_SKIP;
3390 return INPUT_OK;
3391 }
3393 static bool
3394 select_commit_parent(const char *id, char rev[SIZEOF_REV])
3395 {
3396 char buf[SIZEOF_STR * 4];
3397 const char *revlist_argv[] = {
3398 "git", "rev-list", "-1", "--parents", id, NULL
3399 };
3400 int parents;
3402 if (!run_io_buf(revlist_argv, buf, sizeof(buf)) ||
3403 !*chomp_string(buf) ||
3404 (parents = (strlen(buf) / 40) - 1) < 0) {
3405 report("Failed to get parent information");
3406 return FALSE;
3408 } else if (parents == 0) {
3409 report("The selected commit has no parents");
3410 return FALSE;
3411 }
3413 if (parents > 1) {
3414 char prompt[SIZEOF_STR];
3415 char *result;
3417 if (!string_format(prompt, "Which parent? [1..%d] ", parents))
3418 return FALSE;
3419 result = prompt_input(prompt, select_commit_parent_handler, &parents);
3420 if (!result)
3421 return FALSE;
3422 parents = atoi(result);
3423 }
3425 string_copy_rev(rev, &buf[41 * parents]);
3426 return TRUE;
3427 }
3429 /*
3430 * Pager backend
3431 */
3433 static bool
3434 pager_draw(struct view *view, struct line *line, unsigned int lineno)
3435 {
3436 char text[SIZEOF_STR];
3438 if (opt_line_number && draw_lineno(view, lineno))
3439 return TRUE;
3441 string_expand(text, sizeof(text), line->data, opt_tab_size);
3442 draw_text(view, line->type, text, TRUE);
3443 return TRUE;
3444 }
3446 static bool
3447 add_describe_ref(char *buf, size_t *bufpos, const char *commit_id, const char *sep)
3448 {
3449 const char *describe_argv[] = { "git", "describe", commit_id, NULL };
3450 char refbuf[SIZEOF_STR];
3451 char *ref = NULL;
3453 if (run_io_buf(describe_argv, refbuf, sizeof(refbuf)))
3454 ref = chomp_string(refbuf);
3456 if (!ref || !*ref)
3457 return TRUE;
3459 /* This is the only fatal call, since it can "corrupt" the buffer. */
3460 if (!string_nformat(buf, SIZEOF_STR, bufpos, "%s%s", sep, ref))
3461 return FALSE;
3463 return TRUE;
3464 }
3466 static void
3467 add_pager_refs(struct view *view, struct line *line)
3468 {
3469 char buf[SIZEOF_STR];
3470 char *commit_id = (char *)line->data + STRING_SIZE("commit ");
3471 struct ref **refs;
3472 size_t bufpos = 0, refpos = 0;
3473 const char *sep = "Refs: ";
3474 bool is_tag = FALSE;
3476 assert(line->type == LINE_COMMIT);
3478 refs = get_refs(commit_id);
3479 if (!refs) {
3480 if (view == VIEW(REQ_VIEW_DIFF))
3481 goto try_add_describe_ref;
3482 return;
3483 }
3485 do {
3486 struct ref *ref = refs[refpos];
3487 const char *fmt = ref->tag ? "%s[%s]" :
3488 ref->remote ? "%s<%s>" : "%s%s";
3490 if (!string_format_from(buf, &bufpos, fmt, sep, ref->name))
3491 return;
3492 sep = ", ";
3493 if (ref->tag)
3494 is_tag = TRUE;
3495 } while (refs[refpos++]->next);
3497 if (!is_tag && view == VIEW(REQ_VIEW_DIFF)) {
3498 try_add_describe_ref:
3499 /* Add <tag>-g<commit_id> "fake" reference. */
3500 if (!add_describe_ref(buf, &bufpos, commit_id, sep))
3501 return;
3502 }
3504 if (bufpos == 0)
3505 return;
3507 add_line_text(view, buf, LINE_PP_REFS);
3508 }
3510 static bool
3511 pager_read(struct view *view, char *data)
3512 {
3513 struct line *line;
3515 if (!data)
3516 return TRUE;
3518 line = add_line_text(view, data, get_line_type(data));
3519 if (!line)
3520 return FALSE;
3522 if (line->type == LINE_COMMIT &&
3523 (view == VIEW(REQ_VIEW_DIFF) ||
3524 view == VIEW(REQ_VIEW_LOG)))
3525 add_pager_refs(view, line);
3527 return TRUE;
3528 }
3530 static enum request
3531 pager_request(struct view *view, enum request request, struct line *line)
3532 {
3533 int split = 0;
3535 if (request != REQ_ENTER)
3536 return request;
3538 if (line->type == LINE_COMMIT &&
3539 (view == VIEW(REQ_VIEW_LOG) ||
3540 view == VIEW(REQ_VIEW_PAGER))) {
3541 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
3542 split = 1;
3543 }
3545 /* Always scroll the view even if it was split. That way
3546 * you can use Enter to scroll through the log view and
3547 * split open each commit diff. */
3548 scroll_view(view, REQ_SCROLL_LINE_DOWN);
3550 /* FIXME: A minor workaround. Scrolling the view will call report("")
3551 * but if we are scrolling a non-current view this won't properly
3552 * update the view title. */
3553 if (split)
3554 update_view_title(view);
3556 return REQ_NONE;
3557 }
3559 static bool
3560 pager_grep(struct view *view, struct line *line)
3561 {
3562 regmatch_t pmatch;
3563 char *text = line->data;
3565 if (!*text)
3566 return FALSE;
3568 if (regexec(view->regex, text, 1, &pmatch, 0) == REG_NOMATCH)
3569 return FALSE;
3571 return TRUE;
3572 }
3574 static void
3575 pager_select(struct view *view, struct line *line)
3576 {
3577 if (line->type == LINE_COMMIT) {
3578 char *text = (char *)line->data + STRING_SIZE("commit ");
3580 if (view != VIEW(REQ_VIEW_PAGER))
3581 string_copy_rev(view->ref, text);
3582 string_copy_rev(ref_commit, text);
3583 }
3584 }
3586 static struct view_ops pager_ops = {
3587 "line",
3588 NULL,
3589 NULL,
3590 pager_read,
3591 pager_draw,
3592 pager_request,
3593 pager_grep,
3594 pager_select,
3595 };
3597 static const char *log_argv[SIZEOF_ARG] = {
3598 "git", "log", "--no-color", "--cc", "--stat", "-n100", "%(head)", NULL
3599 };
3601 static enum request
3602 log_request(struct view *view, enum request request, struct line *line)
3603 {
3604 switch (request) {
3605 case REQ_REFRESH:
3606 load_refs();
3607 open_view(view, REQ_VIEW_LOG, OPEN_REFRESH);
3608 return REQ_NONE;
3609 default:
3610 return pager_request(view, request, line);
3611 }
3612 }
3614 static struct view_ops log_ops = {
3615 "line",
3616 log_argv,
3617 NULL,
3618 pager_read,
3619 pager_draw,
3620 log_request,
3621 pager_grep,
3622 pager_select,
3623 };
3625 static const char *diff_argv[SIZEOF_ARG] = {
3626 "git", "show", "--pretty=fuller", "--no-color", "--root",
3627 "--patch-with-stat", "--find-copies-harder", "-C", "%(commit)", NULL
3628 };
3630 static struct view_ops diff_ops = {
3631 "line",
3632 diff_argv,
3633 NULL,
3634 pager_read,
3635 pager_draw,
3636 pager_request,
3637 pager_grep,
3638 pager_select,
3639 };
3641 /*
3642 * Help backend
3643 */
3645 static bool
3646 help_open(struct view *view)
3647 {
3648 char buf[SIZEOF_STR];
3649 size_t bufpos;
3650 int i;
3652 if (view->lines > 0)
3653 return TRUE;
3655 add_line_text(view, "Quick reference for tig keybindings:", LINE_DEFAULT);
3657 for (i = 0; i < ARRAY_SIZE(req_info); i++) {
3658 const char *key;
3660 if (req_info[i].request == REQ_NONE)
3661 continue;
3663 if (!req_info[i].request) {
3664 add_line_text(view, "", LINE_DEFAULT);
3665 add_line_text(view, req_info[i].help, LINE_DEFAULT);
3666 continue;
3667 }
3669 key = get_key(req_info[i].request);
3670 if (!*key)
3671 key = "(no key defined)";
3673 for (bufpos = 0; bufpos <= req_info[i].namelen; bufpos++) {
3674 buf[bufpos] = tolower(req_info[i].name[bufpos]);
3675 if (buf[bufpos] == '_')
3676 buf[bufpos] = '-';
3677 }
3679 add_line_format(view, LINE_DEFAULT, " %-25s %-20s %s",
3680 key, buf, req_info[i].help);
3681 }
3683 if (run_requests) {
3684 add_line_text(view, "", LINE_DEFAULT);
3685 add_line_text(view, "External commands:", LINE_DEFAULT);
3686 }
3688 for (i = 0; i < run_requests; i++) {
3689 struct run_request *req = get_run_request(REQ_NONE + i + 1);
3690 const char *key;
3691 int argc;
3693 if (!req)
3694 continue;
3696 key = get_key_name(req->key);
3697 if (!*key)
3698 key = "(no key defined)";
3700 for (bufpos = 0, argc = 0; req->argv[argc]; argc++)
3701 if (!string_format_from(buf, &bufpos, "%s%s",
3702 argc ? " " : "", req->argv[argc]))
3703 return REQ_NONE;
3705 add_line_format(view, LINE_DEFAULT, " %-10s %-14s `%s`",
3706 keymap_table[req->keymap].name, key, buf);
3707 }
3709 return TRUE;
3710 }
3712 static struct view_ops help_ops = {
3713 "line",
3714 NULL,
3715 help_open,
3716 NULL,
3717 pager_draw,
3718 pager_request,
3719 pager_grep,
3720 pager_select,
3721 };
3724 /*
3725 * Tree backend
3726 */
3728 struct tree_stack_entry {
3729 struct tree_stack_entry *prev; /* Entry below this in the stack */
3730 unsigned long lineno; /* Line number to restore */
3731 char *name; /* Position of name in opt_path */
3732 };
3734 /* The top of the path stack. */
3735 static struct tree_stack_entry *tree_stack = NULL;
3736 unsigned long tree_lineno = 0;
3738 static void
3739 pop_tree_stack_entry(void)
3740 {
3741 struct tree_stack_entry *entry = tree_stack;
3743 tree_lineno = entry->lineno;
3744 entry->name[0] = 0;
3745 tree_stack = entry->prev;
3746 free(entry);
3747 }
3749 static void
3750 push_tree_stack_entry(const char *name, unsigned long lineno)
3751 {
3752 struct tree_stack_entry *entry = calloc(1, sizeof(*entry));
3753 size_t pathlen = strlen(opt_path);
3755 if (!entry)
3756 return;
3758 entry->prev = tree_stack;
3759 entry->name = opt_path + pathlen;
3760 tree_stack = entry;
3762 if (!string_format_from(opt_path, &pathlen, "%s/", name)) {
3763 pop_tree_stack_entry();
3764 return;
3765 }
3767 /* Move the current line to the first tree entry. */
3768 tree_lineno = 1;
3769 entry->lineno = lineno;
3770 }
3772 /* Parse output from git-ls-tree(1):
3773 *
3774 * 100644 blob f931e1d229c3e185caad4449bf5b66ed72462657 tig.c
3775 */
3777 #define SIZEOF_TREE_ATTR \
3778 STRING_SIZE("100644 blob f931e1d229c3e185caad4449bf5b66ed72462657\t")
3780 #define SIZEOF_TREE_MODE \
3781 STRING_SIZE("100644 ")
3783 #define TREE_ID_OFFSET \
3784 STRING_SIZE("100644 blob ")
3786 struct tree_entry {
3787 char id[SIZEOF_REV];
3788 mode_t mode;
3789 struct tm time; /* Date from the author ident. */
3790 char author[75]; /* Author of the commit. */
3791 char name[1];
3792 };
3794 static const char *
3795 tree_path(struct line *line)
3796 {
3797 return ((struct tree_entry *) line->data)->name;
3798 }
3801 static int
3802 tree_compare_entry(struct line *line1, struct line *line2)
3803 {
3804 if (line1->type != line2->type)
3805 return line1->type == LINE_TREE_DIR ? -1 : 1;
3806 return strcmp(tree_path(line1), tree_path(line2));
3807 }
3809 static struct line *
3810 tree_entry(struct view *view, enum line_type type, const char *path,
3811 const char *mode, const char *id)
3812 {
3813 struct tree_entry *entry = calloc(1, sizeof(*entry) + strlen(path));
3814 struct line *line = entry ? add_line_data(view, entry, type) : NULL;
3816 if (!entry || !line) {
3817 free(entry);
3818 return NULL;
3819 }
3821 strncpy(entry->name, path, strlen(path));
3822 if (mode)
3823 entry->mode = strtoul(mode, NULL, 8);
3824 if (id)
3825 string_copy_rev(entry->id, id);
3827 return line;
3828 }
3830 static bool
3831 tree_read_date(struct view *view, char *text, bool *read_date)
3832 {
3833 static char author_name[SIZEOF_STR];
3834 static struct tm author_time;
3836 if (!text && *read_date) {
3837 *read_date = FALSE;
3838 return TRUE;
3840 } else if (!text) {
3841 char *path = *opt_path ? opt_path : ".";
3842 /* Find next entry to process */
3843 const char *log_file[] = {
3844 "git", "log", "--no-color", "--pretty=raw",
3845 "--cc", "--raw", view->id, "--", path, NULL
3846 };
3847 struct io io = {};
3849 if (!view->lines) {
3850 tree_entry(view, LINE_TREE_HEAD, opt_path, NULL, NULL);
3851 report("Tree is empty");
3852 return TRUE;
3853 }
3855 if (!run_io_rd(&io, log_file, FORMAT_NONE)) {
3856 report("Failed to load tree data");
3857 return TRUE;
3858 }
3860 done_io(view->pipe);
3861 view->io = io;
3862 *read_date = TRUE;
3863 return FALSE;
3865 } else if (*text == 'a' && get_line_type(text) == LINE_AUTHOR) {
3866 parse_author_line(text + STRING_SIZE("author "),
3867 author_name, sizeof(author_name), &author_time);
3869 } else if (*text == ':') {
3870 char *pos;
3871 size_t annotated = 1;
3872 size_t i;
3874 pos = strchr(text, '\t');
3875 if (!pos)
3876 return TRUE;
3877 text = pos + 1;
3878 if (*opt_prefix && !strncmp(text, opt_prefix, strlen(opt_prefix)))
3879 text += strlen(opt_prefix);
3880 if (*opt_path && !strncmp(text, opt_path, strlen(opt_path)))
3881 text += strlen(opt_path);
3882 pos = strchr(text, '/');
3883 if (pos)
3884 *pos = 0;
3886 for (i = 1; i < view->lines; i++) {
3887 struct line *line = &view->line[i];
3888 struct tree_entry *entry = line->data;
3890 annotated += !!*entry->author;
3891 if (*entry->author || strcmp(entry->name, text))
3892 continue;
3894 string_copy(entry->author, author_name);
3895 memcpy(&entry->time, &author_time, sizeof(entry->time));
3896 line->dirty = 1;
3897 break;
3898 }
3900 if (annotated == view->lines)
3901 kill_io(view->pipe);
3902 }
3903 return TRUE;
3904 }
3906 static bool
3907 tree_read(struct view *view, char *text)
3908 {
3909 static bool read_date = FALSE;
3910 struct tree_entry *data;
3911 struct line *entry, *line;
3912 enum line_type type;
3913 size_t textlen = text ? strlen(text) : 0;
3914 char *path = text + SIZEOF_TREE_ATTR;
3916 if (read_date || !text)
3917 return tree_read_date(view, text, &read_date);
3919 if (textlen <= SIZEOF_TREE_ATTR)
3920 return FALSE;
3921 if (view->lines == 0 &&
3922 !tree_entry(view, LINE_TREE_HEAD, opt_path, NULL, NULL))
3923 return FALSE;
3925 /* Strip the path part ... */
3926 if (*opt_path) {
3927 size_t pathlen = textlen - SIZEOF_TREE_ATTR;
3928 size_t striplen = strlen(opt_path);
3930 if (pathlen > striplen)
3931 memmove(path, path + striplen,
3932 pathlen - striplen + 1);
3934 /* Insert "link" to parent directory. */
3935 if (view->lines == 1 &&
3936 !tree_entry(view, LINE_TREE_DIR, "..", "040000", view->ref))
3937 return FALSE;
3938 }
3940 type = text[SIZEOF_TREE_MODE] == 't' ? LINE_TREE_DIR : LINE_TREE_FILE;
3941 entry = tree_entry(view, type, path, text, text + TREE_ID_OFFSET);
3942 if (!entry)
3943 return FALSE;
3944 data = entry->data;
3946 /* Skip "Directory ..." and ".." line. */
3947 for (line = &view->line[1 + !!*opt_path]; line < entry; line++) {
3948 if (tree_compare_entry(line, entry) <= 0)
3949 continue;
3951 memmove(line + 1, line, (entry - line) * sizeof(*entry));
3953 line->data = data;
3954 line->type = type;
3955 for (; line <= entry; line++)
3956 line->dirty = line->cleareol = 1;
3957 return TRUE;
3958 }
3960 if (tree_lineno > view->lineno) {
3961 view->lineno = tree_lineno;
3962 tree_lineno = 0;
3963 }
3965 return TRUE;
3966 }
3968 static bool
3969 tree_draw(struct view *view, struct line *line, unsigned int lineno)
3970 {
3971 struct tree_entry *entry = line->data;
3973 if (line->type == LINE_TREE_HEAD) {
3974 if (draw_text(view, line->type, "Directory path /", TRUE))
3975 return TRUE;
3976 } else {
3977 if (draw_mode(view, entry->mode))
3978 return TRUE;
3980 if (opt_author && draw_author(view, entry->author))
3981 return TRUE;
3983 if (opt_date && draw_date(view, *entry->author ? &entry->time : NULL))
3984 return TRUE;
3985 }
3986 if (draw_text(view, line->type, entry->name, TRUE))
3987 return TRUE;
3988 return TRUE;
3989 }
3991 static void
3992 open_blob_editor()
3993 {
3994 char file[SIZEOF_STR] = "/tmp/tigblob.XXXXXX";
3995 int fd = mkstemp(file);
3997 if (fd == -1)
3998 report("Failed to create temporary file");
3999 else if (!run_io_append(blob_ops.argv, FORMAT_ALL, fd))
4000 report("Failed to save blob data to file");
4001 else
4002 open_editor(FALSE, file);
4003 if (fd != -1)
4004 unlink(file);
4005 }
4007 static enum request
4008 tree_request(struct view *view, enum request request, struct line *line)
4009 {
4010 enum open_flags flags;
4012 switch (request) {
4013 case REQ_VIEW_BLAME:
4014 if (line->type != LINE_TREE_FILE) {
4015 report("Blame only supported for files");
4016 return REQ_NONE;
4017 }
4019 string_copy(opt_ref, view->vid);
4020 return request;
4022 case REQ_EDIT:
4023 if (line->type != LINE_TREE_FILE) {
4024 report("Edit only supported for files");
4025 } else if (!is_head_commit(view->vid)) {
4026 open_blob_editor();
4027 } else {
4028 open_editor(TRUE, opt_file);
4029 }
4030 return REQ_NONE;
4032 case REQ_PARENT:
4033 if (!*opt_path) {
4034 /* quit view if at top of tree */
4035 return REQ_VIEW_CLOSE;
4036 }
4037 /* fake 'cd ..' */
4038 line = &view->line[1];
4039 break;
4041 case REQ_ENTER:
4042 break;
4044 default:
4045 return request;
4046 }
4048 /* Cleanup the stack if the tree view is at a different tree. */
4049 while (!*opt_path && tree_stack)
4050 pop_tree_stack_entry();
4052 switch (line->type) {
4053 case LINE_TREE_DIR:
4054 /* Depending on whether it is a subdirectory or parent link
4055 * mangle the path buffer. */
4056 if (line == &view->line[1] && *opt_path) {
4057 pop_tree_stack_entry();
4059 } else {
4060 const char *basename = tree_path(line);
4062 push_tree_stack_entry(basename, view->lineno);
4063 }
4065 /* Trees and subtrees share the same ID, so they are not not
4066 * unique like blobs. */
4067 flags = OPEN_RELOAD;
4068 request = REQ_VIEW_TREE;
4069 break;
4071 case LINE_TREE_FILE:
4072 flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
4073 request = REQ_VIEW_BLOB;
4074 break;
4076 default:
4077 return REQ_NONE;
4078 }
4080 open_view(view, request, flags);
4081 if (request == REQ_VIEW_TREE)
4082 view->lineno = tree_lineno;
4084 return REQ_NONE;
4085 }
4087 static void
4088 tree_select(struct view *view, struct line *line)
4089 {
4090 struct tree_entry *entry = line->data;
4092 if (line->type == LINE_TREE_FILE) {
4093 string_copy_rev(ref_blob, entry->id);
4094 string_format(opt_file, "%s%s", opt_path, tree_path(line));
4096 } else if (line->type != LINE_TREE_DIR) {
4097 return;
4098 }
4100 string_copy_rev(view->ref, entry->id);
4101 }
4103 static const char *tree_argv[SIZEOF_ARG] = {
4104 "git", "ls-tree", "%(commit)", "%(directory)", NULL
4105 };
4107 static struct view_ops tree_ops = {
4108 "file",
4109 tree_argv,
4110 NULL,
4111 tree_read,
4112 tree_draw,
4113 tree_request,
4114 pager_grep,
4115 tree_select,
4116 };
4118 static bool
4119 blob_read(struct view *view, char *line)
4120 {
4121 if (!line)
4122 return TRUE;
4123 return add_line_text(view, line, LINE_DEFAULT) != NULL;
4124 }
4126 static enum request
4127 blob_request(struct view *view, enum request request, struct line *line)
4128 {
4129 switch (request) {
4130 case REQ_EDIT:
4131 open_blob_editor();
4132 return REQ_NONE;
4133 default:
4134 return pager_request(view, request, line);
4135 }
4136 }
4138 static const char *blob_argv[SIZEOF_ARG] = {
4139 "git", "cat-file", "blob", "%(blob)", NULL
4140 };
4142 static struct view_ops blob_ops = {
4143 "line",
4144 blob_argv,
4145 NULL,
4146 blob_read,
4147 pager_draw,
4148 blob_request,
4149 pager_grep,
4150 pager_select,
4151 };
4153 /*
4154 * Blame backend
4155 *
4156 * Loading the blame view is a two phase job:
4157 *
4158 * 1. File content is read either using opt_file from the
4159 * filesystem or using git-cat-file.
4160 * 2. Then blame information is incrementally added by
4161 * reading output from git-blame.
4162 */
4164 static const char *blame_head_argv[] = {
4165 "git", "blame", "--incremental", "--", "%(file)", NULL
4166 };
4168 static const char *blame_ref_argv[] = {
4169 "git", "blame", "--incremental", "%(ref)", "--", "%(file)", NULL
4170 };
4172 static const char *blame_cat_file_argv[] = {
4173 "git", "cat-file", "blob", "%(ref):%(file)", NULL
4174 };
4176 struct blame_commit {
4177 char id[SIZEOF_REV]; /* SHA1 ID. */
4178 char title[128]; /* First line of the commit message. */
4179 char author[75]; /* Author of the commit. */
4180 struct tm time; /* Date from the author ident. */
4181 char filename[128]; /* Name of file. */
4182 bool has_previous; /* Was a "previous" line detected. */
4183 };
4185 struct blame {
4186 struct blame_commit *commit;
4187 char text[1];
4188 };
4190 static bool
4191 blame_open(struct view *view)
4192 {
4193 if (*opt_ref || !io_open(&view->io, opt_file)) {
4194 if (!run_io_rd(&view->io, blame_cat_file_argv, FORMAT_ALL))
4195 return FALSE;
4196 }
4198 setup_update(view, opt_file);
4199 string_format(view->ref, "%s ...", opt_file);
4201 return TRUE;
4202 }
4204 static struct blame_commit *
4205 get_blame_commit(struct view *view, const char *id)
4206 {
4207 size_t i;
4209 for (i = 0; i < view->lines; i++) {
4210 struct blame *blame = view->line[i].data;
4212 if (!blame->commit)
4213 continue;
4215 if (!strncmp(blame->commit->id, id, SIZEOF_REV - 1))
4216 return blame->commit;
4217 }
4219 {
4220 struct blame_commit *commit = calloc(1, sizeof(*commit));
4222 if (commit)
4223 string_ncopy(commit->id, id, SIZEOF_REV);
4224 return commit;
4225 }
4226 }
4228 static bool
4229 parse_number(const char **posref, size_t *number, size_t min, size_t max)
4230 {
4231 const char *pos = *posref;
4233 *posref = NULL;
4234 pos = strchr(pos + 1, ' ');
4235 if (!pos || !isdigit(pos[1]))
4236 return FALSE;
4237 *number = atoi(pos + 1);
4238 if (*number < min || *number > max)
4239 return FALSE;
4241 *posref = pos;
4242 return TRUE;
4243 }
4245 static struct blame_commit *
4246 parse_blame_commit(struct view *view, const char *text, int *blamed)
4247 {
4248 struct blame_commit *commit;
4249 struct blame *blame;
4250 const char *pos = text + SIZEOF_REV - 1;
4251 size_t lineno;
4252 size_t group;
4254 if (strlen(text) <= SIZEOF_REV || *pos != ' ')
4255 return NULL;
4257 if (!parse_number(&pos, &lineno, 1, view->lines) ||
4258 !parse_number(&pos, &group, 1, view->lines - lineno + 1))
4259 return NULL;
4261 commit = get_blame_commit(view, text);
4262 if (!commit)
4263 return NULL;
4265 *blamed += group;
4266 while (group--) {
4267 struct line *line = &view->line[lineno + group - 1];
4269 blame = line->data;
4270 blame->commit = commit;
4271 line->dirty = 1;
4272 }
4274 return commit;
4275 }
4277 static bool
4278 blame_read_file(struct view *view, const char *line, bool *read_file)
4279 {
4280 if (!line) {
4281 const char **argv = *opt_ref ? blame_ref_argv : blame_head_argv;
4282 struct io io = {};
4284 if (view->lines == 0 && !view->parent)
4285 die("No blame exist for %s", view->vid);
4287 if (view->lines == 0 || !run_io_rd(&io, argv, FORMAT_ALL)) {
4288 report("Failed to load blame data");
4289 return TRUE;
4290 }
4292 done_io(view->pipe);
4293 view->io = io;
4294 *read_file = FALSE;
4295 return FALSE;
4297 } else {
4298 size_t linelen = string_expand_length(line, opt_tab_size);
4299 struct blame *blame = malloc(sizeof(*blame) + linelen);
4301 if (!blame)
4302 return FALSE;
4304 blame->commit = NULL;
4305 string_expand(blame->text, linelen + 1, line, opt_tab_size);
4306 return add_line_data(view, blame, LINE_BLAME_ID) != NULL;
4307 }
4308 }
4310 static bool
4311 match_blame_header(const char *name, char **line)
4312 {
4313 size_t namelen = strlen(name);
4314 bool matched = !strncmp(name, *line, namelen);
4316 if (matched)
4317 *line += namelen;
4319 return matched;
4320 }
4322 static bool
4323 blame_read(struct view *view, char *line)
4324 {
4325 static struct blame_commit *commit = NULL;
4326 static int blamed = 0;
4327 static time_t author_time;
4328 static bool read_file = TRUE;
4330 if (read_file)
4331 return blame_read_file(view, line, &read_file);
4333 if (!line) {
4334 /* Reset all! */
4335 commit = NULL;
4336 blamed = 0;
4337 read_file = TRUE;
4338 string_format(view->ref, "%s", view->vid);
4339 if (view_is_displayed(view)) {
4340 update_view_title(view);
4341 redraw_view_from(view, 0);
4342 }
4343 return TRUE;
4344 }
4346 if (!commit) {
4347 commit = parse_blame_commit(view, line, &blamed);
4348 string_format(view->ref, "%s %2d%%", view->vid,
4349 view->lines ? blamed * 100 / view->lines : 0);
4351 } else if (match_blame_header("author ", &line)) {
4352 string_ncopy(commit->author, line, strlen(line));
4354 } else if (match_blame_header("author-time ", &line)) {
4355 author_time = (time_t) atol(line);
4357 } else if (match_blame_header("author-tz ", &line)) {
4358 parse_timezone(&author_time, line);
4359 gmtime_r(&author_time, &commit->time);
4361 } else if (match_blame_header("summary ", &line)) {
4362 string_ncopy(commit->title, line, strlen(line));
4364 } else if (match_blame_header("previous ", &line)) {
4365 commit->has_previous = TRUE;
4367 } else if (match_blame_header("filename ", &line)) {
4368 string_ncopy(commit->filename, line, strlen(line));
4369 commit = NULL;
4370 }
4372 return TRUE;
4373 }
4375 static bool
4376 blame_draw(struct view *view, struct line *line, unsigned int lineno)
4377 {
4378 struct blame *blame = line->data;
4379 struct tm *time = NULL;
4380 const char *id = NULL, *author = NULL;
4382 if (blame->commit && *blame->commit->filename) {
4383 id = blame->commit->id;
4384 author = blame->commit->author;
4385 time = &blame->commit->time;
4386 }
4388 if (opt_date && draw_date(view, time))
4389 return TRUE;
4391 if (opt_author && draw_author(view, author))
4392 return TRUE;
4394 if (draw_field(view, LINE_BLAME_ID, id, ID_COLS, FALSE))
4395 return TRUE;
4397 if (draw_lineno(view, lineno))
4398 return TRUE;
4400 draw_text(view, LINE_DEFAULT, blame->text, TRUE);
4401 return TRUE;
4402 }
4404 static bool
4405 check_blame_commit(struct blame *blame)
4406 {
4407 if (!blame->commit)
4408 report("Commit data not loaded yet");
4409 else if (!strcmp(blame->commit->id, NULL_ID))
4410 report("No commit exist for the selected line");
4411 else
4412 return TRUE;
4413 return FALSE;
4414 }
4416 static enum request
4417 blame_request(struct view *view, enum request request, struct line *line)
4418 {
4419 enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
4420 struct blame *blame = line->data;
4422 switch (request) {
4423 case REQ_VIEW_BLAME:
4424 if (check_blame_commit(blame)) {
4425 string_copy(opt_ref, blame->commit->id);
4426 open_view(view, REQ_VIEW_BLAME, OPEN_REFRESH);
4427 }
4428 break;
4430 case REQ_PARENT:
4431 if (check_blame_commit(blame) &&
4432 select_commit_parent(blame->commit->id, opt_ref))
4433 open_view(view, REQ_VIEW_BLAME, OPEN_REFRESH);
4434 break;
4436 case REQ_ENTER:
4437 if (!blame->commit) {
4438 report("No commit loaded yet");
4439 break;
4440 }
4442 if (view_is_displayed(VIEW(REQ_VIEW_DIFF)) &&
4443 !strcmp(blame->commit->id, VIEW(REQ_VIEW_DIFF)->ref))
4444 break;
4446 if (!strcmp(blame->commit->id, NULL_ID)) {
4447 struct view *diff = VIEW(REQ_VIEW_DIFF);
4448 const char *diff_index_argv[] = {
4449 "git", "diff-index", "--root", "--patch-with-stat",
4450 "-C", "-M", "HEAD", "--", view->vid, NULL
4451 };
4453 if (!blame->commit->has_previous) {
4454 diff_index_argv[1] = "diff";
4455 diff_index_argv[2] = "--no-color";
4456 diff_index_argv[6] = "--";
4457 diff_index_argv[7] = "/dev/null";
4458 }
4460 if (!prepare_update(diff, diff_index_argv, NULL, FORMAT_DASH)) {
4461 report("Failed to allocate diff command");
4462 break;
4463 }
4464 flags |= OPEN_PREPARED;
4465 }
4467 open_view(view, REQ_VIEW_DIFF, flags);
4468 if (VIEW(REQ_VIEW_DIFF)->pipe && !strcmp(blame->commit->id, NULL_ID))
4469 string_copy_rev(VIEW(REQ_VIEW_DIFF)->ref, NULL_ID);
4470 break;
4472 default:
4473 return request;
4474 }
4476 return REQ_NONE;
4477 }
4479 static bool
4480 blame_grep(struct view *view, struct line *line)
4481 {
4482 struct blame *blame = line->data;
4483 struct blame_commit *commit = blame->commit;
4484 regmatch_t pmatch;
4486 #define MATCH(text, on) \
4487 (on && *text && regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
4489 if (commit) {
4490 char buf[DATE_COLS + 1];
4492 if (MATCH(commit->title, 1) ||
4493 MATCH(commit->author, opt_author) ||
4494 MATCH(commit->id, opt_date))
4495 return TRUE;
4497 if (strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time) &&
4498 MATCH(buf, 1))
4499 return TRUE;
4500 }
4502 return MATCH(blame->text, 1);
4504 #undef MATCH
4505 }
4507 static void
4508 blame_select(struct view *view, struct line *line)
4509 {
4510 struct blame *blame = line->data;
4511 struct blame_commit *commit = blame->commit;
4513 if (!commit)
4514 return;
4516 if (!strcmp(commit->id, NULL_ID))
4517 string_ncopy(ref_commit, "HEAD", 4);
4518 else
4519 string_copy_rev(ref_commit, commit->id);
4520 }
4522 static struct view_ops blame_ops = {
4523 "line",
4524 NULL,
4525 blame_open,
4526 blame_read,
4527 blame_draw,
4528 blame_request,
4529 blame_grep,
4530 blame_select,
4531 };
4533 /*
4534 * Status backend
4535 */
4537 struct status {
4538 char status;
4539 struct {
4540 mode_t mode;
4541 char rev[SIZEOF_REV];
4542 char name[SIZEOF_STR];
4543 } old;
4544 struct {
4545 mode_t mode;
4546 char rev[SIZEOF_REV];
4547 char name[SIZEOF_STR];
4548 } new;
4549 };
4551 static char status_onbranch[SIZEOF_STR];
4552 static struct status stage_status;
4553 static enum line_type stage_line_type;
4554 static size_t stage_chunks;
4555 static int *stage_chunk;
4557 /* This should work even for the "On branch" line. */
4558 static inline bool
4559 status_has_none(struct view *view, struct line *line)
4560 {
4561 return line < view->line + view->lines && !line[1].data;
4562 }
4564 /* Get fields from the diff line:
4565 * :100644 100644 06a5d6ae9eca55be2e0e585a152e6b1336f2b20e 0000000000000000000000000000000000000000 M
4566 */
4567 static inline bool
4568 status_get_diff(struct status *file, const char *buf, size_t bufsize)
4569 {
4570 const char *old_mode = buf + 1;
4571 const char *new_mode = buf + 8;
4572 const char *old_rev = buf + 15;
4573 const char *new_rev = buf + 56;
4574 const char *status = buf + 97;
4576 if (bufsize < 98 ||
4577 old_mode[-1] != ':' ||
4578 new_mode[-1] != ' ' ||
4579 old_rev[-1] != ' ' ||
4580 new_rev[-1] != ' ' ||
4581 status[-1] != ' ')
4582 return FALSE;
4584 file->status = *status;
4586 string_copy_rev(file->old.rev, old_rev);
4587 string_copy_rev(file->new.rev, new_rev);
4589 file->old.mode = strtoul(old_mode, NULL, 8);
4590 file->new.mode = strtoul(new_mode, NULL, 8);
4592 file->old.name[0] = file->new.name[0] = 0;
4594 return TRUE;
4595 }
4597 static bool
4598 status_run(struct view *view, const char *argv[], char status, enum line_type type)
4599 {
4600 struct status *unmerged = NULL;
4601 char *buf;
4602 struct io io = {};
4604 if (!run_io(&io, argv, NULL, IO_RD))
4605 return FALSE;
4607 add_line_data(view, NULL, type);
4609 while ((buf = io_get(&io, 0, TRUE))) {
4610 struct status *file = unmerged;
4612 if (!file) {
4613 file = calloc(1, sizeof(*file));
4614 if (!file || !add_line_data(view, file, type))
4615 goto error_out;
4616 }
4618 /* Parse diff info part. */
4619 if (status) {
4620 file->status = status;
4621 if (status == 'A')
4622 string_copy(file->old.rev, NULL_ID);
4624 } else if (!file->status || file == unmerged) {
4625 if (!status_get_diff(file, buf, strlen(buf)))
4626 goto error_out;
4628 buf = io_get(&io, 0, TRUE);
4629 if (!buf)
4630 break;
4632 /* Collapse all modified entries that follow an
4633 * associated unmerged entry. */
4634 if (unmerged == file) {
4635 unmerged->status = 'U';
4636 unmerged = NULL;
4637 } else if (file->status == 'U') {
4638 unmerged = file;
4639 }
4640 }
4642 /* Grab the old name for rename/copy. */
4643 if (!*file->old.name &&
4644 (file->status == 'R' || file->status == 'C')) {
4645 string_ncopy(file->old.name, buf, strlen(buf));
4647 buf = io_get(&io, 0, TRUE);
4648 if (!buf)
4649 break;
4650 }
4652 /* git-ls-files just delivers a NUL separated list of
4653 * file names similar to the second half of the
4654 * git-diff-* output. */
4655 string_ncopy(file->new.name, buf, strlen(buf));
4656 if (!*file->old.name)
4657 string_copy(file->old.name, file->new.name);
4658 file = NULL;
4659 }
4661 if (io_error(&io)) {
4662 error_out:
4663 done_io(&io);
4664 return FALSE;
4665 }
4667 if (!view->line[view->lines - 1].data)
4668 add_line_data(view, NULL, LINE_STAT_NONE);
4670 done_io(&io);
4671 return TRUE;
4672 }
4674 /* Don't show unmerged entries in the staged section. */
4675 static const char *status_diff_index_argv[] = {
4676 "git", "diff-index", "-z", "--diff-filter=ACDMRTXB",
4677 "--cached", "-M", "HEAD", NULL
4678 };
4680 static const char *status_diff_files_argv[] = {
4681 "git", "diff-files", "-z", NULL
4682 };
4684 static const char *status_list_other_argv[] = {
4685 "git", "ls-files", "-z", "--others", "--exclude-standard", NULL
4686 };
4688 static const char *status_list_no_head_argv[] = {
4689 "git", "ls-files", "-z", "--cached", "--exclude-standard", NULL
4690 };
4692 static const char *update_index_argv[] = {
4693 "git", "update-index", "-q", "--unmerged", "--refresh", NULL
4694 };
4696 /* Restore the previous line number to stay in the context or select a
4697 * line with something that can be updated. */
4698 static void
4699 status_restore(struct view *view)
4700 {
4701 if (view->p_lineno >= view->lines)
4702 view->p_lineno = view->lines - 1;
4703 while (view->p_lineno < view->lines && !view->line[view->p_lineno].data)
4704 view->p_lineno++;
4705 while (view->p_lineno > 0 && !view->line[view->p_lineno].data)
4706 view->p_lineno--;
4708 /* If the above fails, always skip the "On branch" line. */
4709 if (view->p_lineno < view->lines)
4710 view->lineno = view->p_lineno;
4711 else
4712 view->lineno = 1;
4714 if (view->lineno < view->offset)
4715 view->offset = view->lineno;
4716 else if (view->offset + view->height <= view->lineno)
4717 view->offset = view->lineno - view->height + 1;
4719 view->p_restore = FALSE;
4720 }
4722 static void
4723 status_update_onbranch(void)
4724 {
4725 static const char *paths[][2] = {
4726 { "rebase-apply/rebasing", "Rebasing" },
4727 { "rebase-apply/applying", "Applying mailbox" },
4728 { "rebase-apply/", "Rebasing mailbox" },
4729 { "rebase-merge/interactive", "Interactive rebase" },
4730 { "rebase-merge/", "Rebase merge" },
4731 { "MERGE_HEAD", "Merging" },
4732 { "BISECT_LOG", "Bisecting" },
4733 { "HEAD", "On branch" },
4734 };
4735 char buf[SIZEOF_STR];
4736 struct stat stat;
4737 int i;
4739 if (is_initial_commit()) {
4740 string_copy(status_onbranch, "Initial commit");
4741 return;
4742 }
4744 for (i = 0; i < ARRAY_SIZE(paths); i++) {
4745 char *head = opt_head;
4747 if (!string_format(buf, "%s/%s", opt_git_dir, paths[i][0]) ||
4748 lstat(buf, &stat) < 0)
4749 continue;
4751 if (!*opt_head) {
4752 struct io io = {};
4754 if (string_format(buf, "%s/rebase-merge/head-name", opt_git_dir) &&
4755 io_open(&io, buf) &&
4756 io_read_buf(&io, buf, sizeof(buf))) {
4757 head = chomp_string(buf);
4758 if (!prefixcmp(head, "refs/heads/"))
4759 head += STRING_SIZE("refs/heads/");
4760 }
4761 }
4763 if (!string_format(status_onbranch, "%s %s", paths[i][1], head))
4764 string_copy(status_onbranch, opt_head);
4765 return;
4766 }
4768 string_copy(status_onbranch, "Not currently on any branch");
4769 }
4771 /* First parse staged info using git-diff-index(1), then parse unstaged
4772 * info using git-diff-files(1), and finally untracked files using
4773 * git-ls-files(1). */
4774 static bool
4775 status_open(struct view *view)
4776 {
4777 reset_view(view);
4779 add_line_data(view, NULL, LINE_STAT_HEAD);
4780 status_update_onbranch();
4782 run_io_bg(update_index_argv);
4784 if (is_initial_commit()) {
4785 if (!status_run(view, status_list_no_head_argv, 'A', LINE_STAT_STAGED))
4786 return FALSE;
4787 } else if (!status_run(view, status_diff_index_argv, 0, LINE_STAT_STAGED)) {
4788 return FALSE;
4789 }
4791 if (!status_run(view, status_diff_files_argv, 0, LINE_STAT_UNSTAGED) ||
4792 !status_run(view, status_list_other_argv, '?', LINE_STAT_UNTRACKED))
4793 return FALSE;
4795 /* Restore the exact position or use the specialized restore
4796 * mode? */
4797 if (!view->p_restore)
4798 status_restore(view);
4799 return TRUE;
4800 }
4802 static bool
4803 status_draw(struct view *view, struct line *line, unsigned int lineno)
4804 {
4805 struct status *status = line->data;
4806 enum line_type type;
4807 const char *text;
4809 if (!status) {
4810 switch (line->type) {
4811 case LINE_STAT_STAGED:
4812 type = LINE_STAT_SECTION;
4813 text = "Changes to be committed:";
4814 break;
4816 case LINE_STAT_UNSTAGED:
4817 type = LINE_STAT_SECTION;
4818 text = "Changed but not updated:";
4819 break;
4821 case LINE_STAT_UNTRACKED:
4822 type = LINE_STAT_SECTION;
4823 text = "Untracked files:";
4824 break;
4826 case LINE_STAT_NONE:
4827 type = LINE_DEFAULT;
4828 text = " (no files)";
4829 break;
4831 case LINE_STAT_HEAD:
4832 type = LINE_STAT_HEAD;
4833 text = status_onbranch;
4834 break;
4836 default:
4837 return FALSE;
4838 }
4839 } else {
4840 static char buf[] = { '?', ' ', ' ', ' ', 0 };
4842 buf[0] = status->status;
4843 if (draw_text(view, line->type, buf, TRUE))
4844 return TRUE;
4845 type = LINE_DEFAULT;
4846 text = status->new.name;
4847 }
4849 draw_text(view, type, text, TRUE);
4850 return TRUE;
4851 }
4853 static enum request
4854 status_enter(struct view *view, struct line *line)
4855 {
4856 struct status *status = line->data;
4857 const char *oldpath = status ? status->old.name : NULL;
4858 /* Diffs for unmerged entries are empty when passing the new
4859 * path, so leave it empty. */
4860 const char *newpath = status && status->status != 'U' ? status->new.name : NULL;
4861 const char *info;
4862 enum open_flags split;
4863 struct view *stage = VIEW(REQ_VIEW_STAGE);
4865 if (line->type == LINE_STAT_NONE ||
4866 (!status && line[1].type == LINE_STAT_NONE)) {
4867 report("No file to diff");
4868 return REQ_NONE;
4869 }
4871 switch (line->type) {
4872 case LINE_STAT_STAGED:
4873 if (is_initial_commit()) {
4874 const char *no_head_diff_argv[] = {
4875 "git", "diff", "--no-color", "--patch-with-stat",
4876 "--", "/dev/null", newpath, NULL
4877 };
4879 if (!prepare_update(stage, no_head_diff_argv, opt_cdup, FORMAT_DASH))
4880 return REQ_QUIT;
4881 } else {
4882 const char *index_show_argv[] = {
4883 "git", "diff-index", "--root", "--patch-with-stat",
4884 "-C", "-M", "--cached", "HEAD", "--",
4885 oldpath, newpath, NULL
4886 };
4888 if (!prepare_update(stage, index_show_argv, opt_cdup, FORMAT_DASH))
4889 return REQ_QUIT;
4890 }
4892 if (status)
4893 info = "Staged changes to %s";
4894 else
4895 info = "Staged changes";
4896 break;
4898 case LINE_STAT_UNSTAGED:
4899 {
4900 const char *files_show_argv[] = {
4901 "git", "diff-files", "--root", "--patch-with-stat",
4902 "-C", "-M", "--", oldpath, newpath, NULL
4903 };
4905 if (!prepare_update(stage, files_show_argv, opt_cdup, FORMAT_DASH))
4906 return REQ_QUIT;
4907 if (status)
4908 info = "Unstaged changes to %s";
4909 else
4910 info = "Unstaged changes";
4911 break;
4912 }
4913 case LINE_STAT_UNTRACKED:
4914 if (!newpath) {
4915 report("No file to show");
4916 return REQ_NONE;
4917 }
4919 if (!suffixcmp(status->new.name, -1, "/")) {
4920 report("Cannot display a directory");
4921 return REQ_NONE;
4922 }
4924 if (!prepare_update_file(stage, newpath))
4925 return REQ_QUIT;
4926 info = "Untracked file %s";
4927 break;
4929 case LINE_STAT_HEAD:
4930 return REQ_NONE;
4932 default:
4933 die("line type %d not handled in switch", line->type);
4934 }
4936 split = view_is_displayed(view) ? OPEN_SPLIT : 0;
4937 open_view(view, REQ_VIEW_STAGE, OPEN_PREPARED | split);
4938 if (view_is_displayed(VIEW(REQ_VIEW_STAGE))) {
4939 if (status) {
4940 stage_status = *status;
4941 } else {
4942 memset(&stage_status, 0, sizeof(stage_status));
4943 }
4945 stage_line_type = line->type;
4946 stage_chunks = 0;
4947 string_format(VIEW(REQ_VIEW_STAGE)->ref, info, stage_status.new.name);
4948 }
4950 return REQ_NONE;
4951 }
4953 static bool
4954 status_exists(struct status *status, enum line_type type)
4955 {
4956 struct view *view = VIEW(REQ_VIEW_STATUS);
4957 unsigned long lineno;
4959 for (lineno = 0; lineno < view->lines; lineno++) {
4960 struct line *line = &view->line[lineno];
4961 struct status *pos = line->data;
4963 if (line->type != type)
4964 continue;
4965 if (!pos && (!status || !status->status) && line[1].data) {
4966 select_view_line(view, lineno);
4967 return TRUE;
4968 }
4969 if (pos && !strcmp(status->new.name, pos->new.name)) {
4970 select_view_line(view, lineno);
4971 return TRUE;
4972 }
4973 }
4975 return FALSE;
4976 }
4979 static bool
4980 status_update_prepare(struct io *io, enum line_type type)
4981 {
4982 const char *staged_argv[] = {
4983 "git", "update-index", "-z", "--index-info", NULL
4984 };
4985 const char *others_argv[] = {
4986 "git", "update-index", "-z", "--add", "--remove", "--stdin", NULL
4987 };
4989 switch (type) {
4990 case LINE_STAT_STAGED:
4991 return run_io(io, staged_argv, opt_cdup, IO_WR);
4993 case LINE_STAT_UNSTAGED:
4994 return run_io(io, others_argv, opt_cdup, IO_WR);
4996 case LINE_STAT_UNTRACKED:
4997 return run_io(io, others_argv, NULL, IO_WR);
4999 default:
5000 die("line type %d not handled in switch", type);
5001 return FALSE;
5002 }
5003 }
5005 static bool
5006 status_update_write(struct io *io, struct status *status, enum line_type type)
5007 {
5008 char buf[SIZEOF_STR];
5009 size_t bufsize = 0;
5011 switch (type) {
5012 case LINE_STAT_STAGED:
5013 if (!string_format_from(buf, &bufsize, "%06o %s\t%s%c",
5014 status->old.mode,
5015 status->old.rev,
5016 status->old.name, 0))
5017 return FALSE;
5018 break;
5020 case LINE_STAT_UNSTAGED:
5021 case LINE_STAT_UNTRACKED:
5022 if (!string_format_from(buf, &bufsize, "%s%c", status->new.name, 0))
5023 return FALSE;
5024 break;
5026 default:
5027 die("line type %d not handled in switch", type);
5028 }
5030 return io_write(io, buf, bufsize);
5031 }
5033 static bool
5034 status_update_file(struct status *status, enum line_type type)
5035 {
5036 struct io io = {};
5037 bool result;
5039 if (!status_update_prepare(&io, type))
5040 return FALSE;
5042 result = status_update_write(&io, status, type);
5043 done_io(&io);
5044 return result;
5045 }
5047 static bool
5048 status_update_files(struct view *view, struct line *line)
5049 {
5050 struct io io = {};
5051 bool result = TRUE;
5052 struct line *pos = view->line + view->lines;
5053 int files = 0;
5054 int file, done;
5056 if (!status_update_prepare(&io, line->type))
5057 return FALSE;
5059 for (pos = line; pos < view->line + view->lines && pos->data; pos++)
5060 files++;
5062 for (file = 0, done = 0; result && file < files; line++, file++) {
5063 int almost_done = file * 100 / files;
5065 if (almost_done > done) {
5066 done = almost_done;
5067 string_format(view->ref, "updating file %u of %u (%d%% done)",
5068 file, files, done);
5069 update_view_title(view);
5070 }
5071 result = status_update_write(&io, line->data, line->type);
5072 }
5074 done_io(&io);
5075 return result;
5076 }
5078 static bool
5079 status_update(struct view *view)
5080 {
5081 struct line *line = &view->line[view->lineno];
5083 assert(view->lines);
5085 if (!line->data) {
5086 /* This should work even for the "On branch" line. */
5087 if (line < view->line + view->lines && !line[1].data) {
5088 report("Nothing to update");
5089 return FALSE;
5090 }
5092 if (!status_update_files(view, line + 1)) {
5093 report("Failed to update file status");
5094 return FALSE;
5095 }
5097 } else if (!status_update_file(line->data, line->type)) {
5098 report("Failed to update file status");
5099 return FALSE;
5100 }
5102 return TRUE;
5103 }
5105 static bool
5106 status_revert(struct status *status, enum line_type type, bool has_none)
5107 {
5108 if (!status || type != LINE_STAT_UNSTAGED) {
5109 if (type == LINE_STAT_STAGED) {
5110 report("Cannot revert changes to staged files");
5111 } else if (type == LINE_STAT_UNTRACKED) {
5112 report("Cannot revert changes to untracked files");
5113 } else if (has_none) {
5114 report("Nothing to revert");
5115 } else {
5116 report("Cannot revert changes to multiple files");
5117 }
5118 return FALSE;
5120 } else {
5121 char mode[10] = "100644";
5122 const char *reset_argv[] = {
5123 "git", "update-index", "--cacheinfo", mode,
5124 status->old.rev, status->old.name, NULL
5125 };
5126 const char *checkout_argv[] = {
5127 "git", "checkout", "--", status->old.name, NULL
5128 };
5130 if (!prompt_yesno("Are you sure you want to overwrite any changes?"))
5131 return FALSE;
5132 string_format(mode, "%o", status->old.mode);
5133 return (status->status != 'U' || run_io_fg(reset_argv, opt_cdup)) &&
5134 run_io_fg(checkout_argv, opt_cdup);
5135 }
5136 }
5138 static enum request
5139 status_request(struct view *view, enum request request, struct line *line)
5140 {
5141 struct status *status = line->data;
5143 switch (request) {
5144 case REQ_STATUS_UPDATE:
5145 if (!status_update(view))
5146 return REQ_NONE;
5147 break;
5149 case REQ_STATUS_REVERT:
5150 if (!status_revert(status, line->type, status_has_none(view, line)))
5151 return REQ_NONE;
5152 break;
5154 case REQ_STATUS_MERGE:
5155 if (!status || status->status != 'U') {
5156 report("Merging only possible for files with unmerged status ('U').");
5157 return REQ_NONE;
5158 }
5159 open_mergetool(status->new.name);
5160 break;
5162 case REQ_EDIT:
5163 if (!status)
5164 return request;
5165 if (status->status == 'D') {
5166 report("File has been deleted.");
5167 return REQ_NONE;
5168 }
5170 open_editor(status->status != '?', status->new.name);
5171 break;
5173 case REQ_VIEW_BLAME:
5174 if (status) {
5175 string_copy(opt_file, status->new.name);
5176 opt_ref[0] = 0;
5177 }
5178 return request;
5180 case REQ_ENTER:
5181 /* After returning the status view has been split to
5182 * show the stage view. No further reloading is
5183 * necessary. */
5184 status_enter(view, line);
5185 return REQ_NONE;
5187 case REQ_REFRESH:
5188 /* Simply reload the view. */
5189 break;
5191 default:
5192 return request;
5193 }
5195 open_view(view, REQ_VIEW_STATUS, OPEN_RELOAD);
5197 return REQ_NONE;
5198 }
5200 static void
5201 status_select(struct view *view, struct line *line)
5202 {
5203 struct status *status = line->data;
5204 char file[SIZEOF_STR] = "all files";
5205 const char *text;
5206 const char *key;
5208 if (status && !string_format(file, "'%s'", status->new.name))
5209 return;
5211 if (!status && line[1].type == LINE_STAT_NONE)
5212 line++;
5214 switch (line->type) {
5215 case LINE_STAT_STAGED:
5216 text = "Press %s to unstage %s for commit";
5217 break;
5219 case LINE_STAT_UNSTAGED:
5220 text = "Press %s to stage %s for commit";
5221 break;
5223 case LINE_STAT_UNTRACKED:
5224 text = "Press %s to stage %s for addition";
5225 break;
5227 case LINE_STAT_HEAD:
5228 case LINE_STAT_NONE:
5229 text = "Nothing to update";
5230 break;
5232 default:
5233 die("line type %d not handled in switch", line->type);
5234 }
5236 if (status && status->status == 'U') {
5237 text = "Press %s to resolve conflict in %s";
5238 key = get_key(REQ_STATUS_MERGE);
5240 } else {
5241 key = get_key(REQ_STATUS_UPDATE);
5242 }
5244 string_format(view->ref, text, key, file);
5245 }
5247 static bool
5248 status_grep(struct view *view, struct line *line)
5249 {
5250 struct status *status = line->data;
5251 enum { S_STATUS, S_NAME, S_END } state;
5252 char buf[2] = "?";
5253 regmatch_t pmatch;
5255 if (!status)
5256 return FALSE;
5258 for (state = S_STATUS; state < S_END; state++) {
5259 const char *text;
5261 switch (state) {
5262 case S_NAME: text = status->new.name; break;
5263 case S_STATUS:
5264 buf[0] = status->status;
5265 text = buf;
5266 break;
5268 default:
5269 return FALSE;
5270 }
5272 if (regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
5273 return TRUE;
5274 }
5276 return FALSE;
5277 }
5279 static struct view_ops status_ops = {
5280 "file",
5281 NULL,
5282 status_open,
5283 NULL,
5284 status_draw,
5285 status_request,
5286 status_grep,
5287 status_select,
5288 };
5291 static bool
5292 stage_diff_write(struct io *io, struct line *line, struct line *end)
5293 {
5294 while (line < end) {
5295 if (!io_write(io, line->data, strlen(line->data)) ||
5296 !io_write(io, "\n", 1))
5297 return FALSE;
5298 line++;
5299 if (line->type == LINE_DIFF_CHUNK ||
5300 line->type == LINE_DIFF_HEADER)
5301 break;
5302 }
5304 return TRUE;
5305 }
5307 static struct line *
5308 stage_diff_find(struct view *view, struct line *line, enum line_type type)
5309 {
5310 for (; view->line < line; line--)
5311 if (line->type == type)
5312 return line;
5314 return NULL;
5315 }
5317 static bool
5318 stage_apply_chunk(struct view *view, struct line *chunk, bool revert)
5319 {
5320 const char *apply_argv[SIZEOF_ARG] = {
5321 "git", "apply", "--whitespace=nowarn", NULL
5322 };
5323 struct line *diff_hdr;
5324 struct io io = {};
5325 int argc = 3;
5327 diff_hdr = stage_diff_find(view, chunk, LINE_DIFF_HEADER);
5328 if (!diff_hdr)
5329 return FALSE;
5331 if (!revert)
5332 apply_argv[argc++] = "--cached";
5333 if (revert || stage_line_type == LINE_STAT_STAGED)
5334 apply_argv[argc++] = "-R";
5335 apply_argv[argc++] = "-";
5336 apply_argv[argc++] = NULL;
5337 if (!run_io(&io, apply_argv, opt_cdup, IO_WR))
5338 return FALSE;
5340 if (!stage_diff_write(&io, diff_hdr, chunk) ||
5341 !stage_diff_write(&io, chunk, view->line + view->lines))
5342 chunk = NULL;
5344 done_io(&io);
5345 run_io_bg(update_index_argv);
5347 return chunk ? TRUE : FALSE;
5348 }
5350 static bool
5351 stage_update(struct view *view, struct line *line)
5352 {
5353 struct line *chunk = NULL;
5355 if (!is_initial_commit() && stage_line_type != LINE_STAT_UNTRACKED)
5356 chunk = stage_diff_find(view, line, LINE_DIFF_CHUNK);
5358 if (chunk) {
5359 if (!stage_apply_chunk(view, chunk, FALSE)) {
5360 report("Failed to apply chunk");
5361 return FALSE;
5362 }
5364 } else if (!stage_status.status) {
5365 view = VIEW(REQ_VIEW_STATUS);
5367 for (line = view->line; line < view->line + view->lines; line++)
5368 if (line->type == stage_line_type)
5369 break;
5371 if (!status_update_files(view, line + 1)) {
5372 report("Failed to update files");
5373 return FALSE;
5374 }
5376 } else if (!status_update_file(&stage_status, stage_line_type)) {
5377 report("Failed to update file");
5378 return FALSE;
5379 }
5381 return TRUE;
5382 }
5384 static bool
5385 stage_revert(struct view *view, struct line *line)
5386 {
5387 struct line *chunk = NULL;
5389 if (!is_initial_commit() && stage_line_type == LINE_STAT_UNSTAGED)
5390 chunk = stage_diff_find(view, line, LINE_DIFF_CHUNK);
5392 if (chunk) {
5393 if (!prompt_yesno("Are you sure you want to revert changes?"))
5394 return FALSE;
5396 if (!stage_apply_chunk(view, chunk, TRUE)) {
5397 report("Failed to revert chunk");
5398 return FALSE;
5399 }
5400 return TRUE;
5402 } else {
5403 return status_revert(stage_status.status ? &stage_status : NULL,
5404 stage_line_type, FALSE);
5405 }
5406 }
5409 static void
5410 stage_next(struct view *view, struct line *line)
5411 {
5412 int i;
5414 if (!stage_chunks) {
5415 static size_t alloc = 0;
5416 int *tmp;
5418 for (line = view->line; line < view->line + view->lines; line++) {
5419 if (line->type != LINE_DIFF_CHUNK)
5420 continue;
5422 tmp = realloc_items(stage_chunk, &alloc,
5423 stage_chunks, sizeof(*tmp));
5424 if (!tmp) {
5425 report("Allocation failure");
5426 return;
5427 }
5429 stage_chunk = tmp;
5430 stage_chunk[stage_chunks++] = line - view->line;
5431 }
5432 }
5434 for (i = 0; i < stage_chunks; i++) {
5435 if (stage_chunk[i] > view->lineno) {
5436 do_scroll_view(view, stage_chunk[i] - view->lineno);
5437 report("Chunk %d of %d", i + 1, stage_chunks);
5438 return;
5439 }
5440 }
5442 report("No next chunk found");
5443 }
5445 static enum request
5446 stage_request(struct view *view, enum request request, struct line *line)
5447 {
5448 switch (request) {
5449 case REQ_STATUS_UPDATE:
5450 if (!stage_update(view, line))
5451 return REQ_NONE;
5452 break;
5454 case REQ_STATUS_REVERT:
5455 if (!stage_revert(view, line))
5456 return REQ_NONE;
5457 break;
5459 case REQ_STAGE_NEXT:
5460 if (stage_line_type == LINE_STAT_UNTRACKED) {
5461 report("File is untracked; press %s to add",
5462 get_key(REQ_STATUS_UPDATE));
5463 return REQ_NONE;
5464 }
5465 stage_next(view, line);
5466 return REQ_NONE;
5468 case REQ_EDIT:
5469 if (!stage_status.new.name[0])
5470 return request;
5471 if (stage_status.status == 'D') {
5472 report("File has been deleted.");
5473 return REQ_NONE;
5474 }
5476 open_editor(stage_status.status != '?', stage_status.new.name);
5477 break;
5479 case REQ_REFRESH:
5480 /* Reload everything ... */
5481 break;
5483 case REQ_VIEW_BLAME:
5484 if (stage_status.new.name[0]) {
5485 string_copy(opt_file, stage_status.new.name);
5486 opt_ref[0] = 0;
5487 }
5488 return request;
5490 case REQ_ENTER:
5491 return pager_request(view, request, line);
5493 default:
5494 return request;
5495 }
5497 VIEW(REQ_VIEW_STATUS)->p_restore = TRUE;
5498 open_view(view, REQ_VIEW_STATUS, OPEN_REFRESH);
5500 /* Check whether the staged entry still exists, and close the
5501 * stage view if it doesn't. */
5502 if (!status_exists(&stage_status, stage_line_type)) {
5503 status_restore(VIEW(REQ_VIEW_STATUS));
5504 return REQ_VIEW_CLOSE;
5505 }
5507 if (stage_line_type == LINE_STAT_UNTRACKED) {
5508 if (!suffixcmp(stage_status.new.name, -1, "/")) {
5509 report("Cannot display a directory");
5510 return REQ_NONE;
5511 }
5513 if (!prepare_update_file(view, stage_status.new.name)) {
5514 report("Failed to open file: %s", strerror(errno));
5515 return REQ_NONE;
5516 }
5517 }
5518 open_view(view, REQ_VIEW_STAGE, OPEN_REFRESH);
5520 return REQ_NONE;
5521 }
5523 static struct view_ops stage_ops = {
5524 "line",
5525 NULL,
5526 NULL,
5527 pager_read,
5528 pager_draw,
5529 stage_request,
5530 pager_grep,
5531 pager_select,
5532 };
5535 /*
5536 * Revision graph
5537 */
5539 struct commit {
5540 char id[SIZEOF_REV]; /* SHA1 ID. */
5541 char title[128]; /* First line of the commit message. */
5542 char author[75]; /* Author of the commit. */
5543 struct tm time; /* Date from the author ident. */
5544 struct ref **refs; /* Repository references. */
5545 chtype graph[SIZEOF_REVGRAPH]; /* Ancestry chain graphics. */
5546 size_t graph_size; /* The width of the graph array. */
5547 bool has_parents; /* Rewritten --parents seen. */
5548 };
5550 /* Size of rev graph with no "padding" columns */
5551 #define SIZEOF_REVITEMS (SIZEOF_REVGRAPH - (SIZEOF_REVGRAPH / 2))
5553 struct rev_graph {
5554 struct rev_graph *prev, *next, *parents;
5555 char rev[SIZEOF_REVITEMS][SIZEOF_REV];
5556 size_t size;
5557 struct commit *commit;
5558 size_t pos;
5559 unsigned int boundary:1;
5560 };
5562 /* Parents of the commit being visualized. */
5563 static struct rev_graph graph_parents[4];
5565 /* The current stack of revisions on the graph. */
5566 static struct rev_graph graph_stacks[4] = {
5567 { &graph_stacks[3], &graph_stacks[1], &graph_parents[0] },
5568 { &graph_stacks[0], &graph_stacks[2], &graph_parents[1] },
5569 { &graph_stacks[1], &graph_stacks[3], &graph_parents[2] },
5570 { &graph_stacks[2], &graph_stacks[0], &graph_parents[3] },
5571 };
5573 static inline bool
5574 graph_parent_is_merge(struct rev_graph *graph)
5575 {
5576 return graph->parents->size > 1;
5577 }
5579 static inline void
5580 append_to_rev_graph(struct rev_graph *graph, chtype symbol)
5581 {
5582 struct commit *commit = graph->commit;
5584 if (commit->graph_size < ARRAY_SIZE(commit->graph) - 1)
5585 commit->graph[commit->graph_size++] = symbol;
5586 }
5588 static void
5589 clear_rev_graph(struct rev_graph *graph)
5590 {
5591 graph->boundary = 0;
5592 graph->size = graph->pos = 0;
5593 graph->commit = NULL;
5594 memset(graph->parents, 0, sizeof(*graph->parents));
5595 }
5597 static void
5598 done_rev_graph(struct rev_graph *graph)
5599 {
5600 if (graph_parent_is_merge(graph) &&
5601 graph->pos < graph->size - 1 &&
5602 graph->next->size == graph->size + graph->parents->size - 1) {
5603 size_t i = graph->pos + graph->parents->size - 1;
5605 graph->commit->graph_size = i * 2;
5606 while (i < graph->next->size - 1) {
5607 append_to_rev_graph(graph, ' ');
5608 append_to_rev_graph(graph, '\\');
5609 i++;
5610 }
5611 }
5613 clear_rev_graph(graph);
5614 }
5616 static void
5617 push_rev_graph(struct rev_graph *graph, const char *parent)
5618 {
5619 int i;
5621 /* "Collapse" duplicate parents lines.
5622 *
5623 * FIXME: This needs to also update update the drawn graph but
5624 * for now it just serves as a method for pruning graph lines. */
5625 for (i = 0; i < graph->size; i++)
5626 if (!strncmp(graph->rev[i], parent, SIZEOF_REV))
5627 return;
5629 if (graph->size < SIZEOF_REVITEMS) {
5630 string_copy_rev(graph->rev[graph->size++], parent);
5631 }
5632 }
5634 static chtype
5635 get_rev_graph_symbol(struct rev_graph *graph)
5636 {
5637 chtype symbol;
5639 if (graph->boundary)
5640 symbol = REVGRAPH_BOUND;
5641 else if (graph->parents->size == 0)
5642 symbol = REVGRAPH_INIT;
5643 else if (graph_parent_is_merge(graph))
5644 symbol = REVGRAPH_MERGE;
5645 else if (graph->pos >= graph->size)
5646 symbol = REVGRAPH_BRANCH;
5647 else
5648 symbol = REVGRAPH_COMMIT;
5650 return symbol;
5651 }
5653 static void
5654 draw_rev_graph(struct rev_graph *graph)
5655 {
5656 struct rev_filler {
5657 chtype separator, line;
5658 };
5659 enum { DEFAULT, RSHARP, RDIAG, LDIAG };
5660 static struct rev_filler fillers[] = {
5661 { ' ', '|' },
5662 { '`', '.' },
5663 { '\'', ' ' },
5664 { '/', ' ' },
5665 };
5666 chtype symbol = get_rev_graph_symbol(graph);
5667 struct rev_filler *filler;
5668 size_t i;
5670 if (opt_line_graphics)
5671 fillers[DEFAULT].line = line_graphics[LINE_GRAPHIC_VLINE];
5673 filler = &fillers[DEFAULT];
5675 for (i = 0; i < graph->pos; i++) {
5676 append_to_rev_graph(graph, filler->line);
5677 if (graph_parent_is_merge(graph->prev) &&
5678 graph->prev->pos == i)
5679 filler = &fillers[RSHARP];
5681 append_to_rev_graph(graph, filler->separator);
5682 }
5684 /* Place the symbol for this revision. */
5685 append_to_rev_graph(graph, symbol);
5687 if (graph->prev->size > graph->size)
5688 filler = &fillers[RDIAG];
5689 else
5690 filler = &fillers[DEFAULT];
5692 i++;
5694 for (; i < graph->size; i++) {
5695 append_to_rev_graph(graph, filler->separator);
5696 append_to_rev_graph(graph, filler->line);
5697 if (graph_parent_is_merge(graph->prev) &&
5698 i < graph->prev->pos + graph->parents->size)
5699 filler = &fillers[RSHARP];
5700 if (graph->prev->size > graph->size)
5701 filler = &fillers[LDIAG];
5702 }
5704 if (graph->prev->size > graph->size) {
5705 append_to_rev_graph(graph, filler->separator);
5706 if (filler->line != ' ')
5707 append_to_rev_graph(graph, filler->line);
5708 }
5709 }
5711 /* Prepare the next rev graph */
5712 static void
5713 prepare_rev_graph(struct rev_graph *graph)
5714 {
5715 size_t i;
5717 /* First, traverse all lines of revisions up to the active one. */
5718 for (graph->pos = 0; graph->pos < graph->size; graph->pos++) {
5719 if (!strcmp(graph->rev[graph->pos], graph->commit->id))
5720 break;
5722 push_rev_graph(graph->next, graph->rev[graph->pos]);
5723 }
5725 /* Interleave the new revision parent(s). */
5726 for (i = 0; !graph->boundary && i < graph->parents->size; i++)
5727 push_rev_graph(graph->next, graph->parents->rev[i]);
5729 /* Lastly, put any remaining revisions. */
5730 for (i = graph->pos + 1; i < graph->size; i++)
5731 push_rev_graph(graph->next, graph->rev[i]);
5732 }
5734 static void
5735 update_rev_graph(struct view *view, struct rev_graph *graph)
5736 {
5737 /* If this is the finalizing update ... */
5738 if (graph->commit)
5739 prepare_rev_graph(graph);
5741 /* Graph visualization needs a one rev look-ahead,
5742 * so the first update doesn't visualize anything. */
5743 if (!graph->prev->commit)
5744 return;
5746 if (view->lines > 2)
5747 view->line[view->lines - 3].dirty = 1;
5748 if (view->lines > 1)
5749 view->line[view->lines - 2].dirty = 1;
5750 draw_rev_graph(graph->prev);
5751 done_rev_graph(graph->prev->prev);
5752 }
5755 /*
5756 * Main view backend
5757 */
5759 static const char *main_argv[SIZEOF_ARG] = {
5760 "git", "log", "--no-color", "--pretty=raw", "--parents",
5761 "--topo-order", "%(head)", NULL
5762 };
5764 static bool
5765 main_draw(struct view *view, struct line *line, unsigned int lineno)
5766 {
5767 struct commit *commit = line->data;
5769 if (!*commit->author)
5770 return FALSE;
5772 if (opt_date && draw_date(view, &commit->time))
5773 return TRUE;
5775 if (opt_author && draw_author(view, commit->author))
5776 return TRUE;
5778 if (opt_rev_graph && commit->graph_size &&
5779 draw_graphic(view, LINE_MAIN_REVGRAPH, commit->graph, commit->graph_size))
5780 return TRUE;
5782 if (opt_show_refs && commit->refs) {
5783 size_t i = 0;
5785 do {
5786 enum line_type type;
5788 if (commit->refs[i]->head)
5789 type = LINE_MAIN_HEAD;
5790 else if (commit->refs[i]->ltag)
5791 type = LINE_MAIN_LOCAL_TAG;
5792 else if (commit->refs[i]->tag)
5793 type = LINE_MAIN_TAG;
5794 else if (commit->refs[i]->tracked)
5795 type = LINE_MAIN_TRACKED;
5796 else if (commit->refs[i]->remote)
5797 type = LINE_MAIN_REMOTE;
5798 else
5799 type = LINE_MAIN_REF;
5801 if (draw_text(view, type, "[", TRUE) ||
5802 draw_text(view, type, commit->refs[i]->name, TRUE) ||
5803 draw_text(view, type, "]", TRUE))
5804 return TRUE;
5806 if (draw_text(view, LINE_DEFAULT, " ", TRUE))
5807 return TRUE;
5808 } while (commit->refs[i++]->next);
5809 }
5811 draw_text(view, LINE_DEFAULT, commit->title, TRUE);
5812 return TRUE;
5813 }
5815 /* Reads git log --pretty=raw output and parses it into the commit struct. */
5816 static bool
5817 main_read(struct view *view, char *line)
5818 {
5819 static struct rev_graph *graph = graph_stacks;
5820 enum line_type type;
5821 struct commit *commit;
5823 if (!line) {
5824 int i;
5826 if (!view->lines && !view->parent)
5827 die("No revisions match the given arguments.");
5828 if (view->lines > 0) {
5829 commit = view->line[view->lines - 1].data;
5830 view->line[view->lines - 1].dirty = 1;
5831 if (!*commit->author) {
5832 view->lines--;
5833 free(commit);
5834 graph->commit = NULL;
5835 }
5836 }
5837 update_rev_graph(view, graph);
5839 for (i = 0; i < ARRAY_SIZE(graph_stacks); i++)
5840 clear_rev_graph(&graph_stacks[i]);
5841 return TRUE;
5842 }
5844 type = get_line_type(line);
5845 if (type == LINE_COMMIT) {
5846 commit = calloc(1, sizeof(struct commit));
5847 if (!commit)
5848 return FALSE;
5850 line += STRING_SIZE("commit ");
5851 if (*line == '-') {
5852 graph->boundary = 1;
5853 line++;
5854 }
5856 string_copy_rev(commit->id, line);
5857 commit->refs = get_refs(commit->id);
5858 graph->commit = commit;
5859 add_line_data(view, commit, LINE_MAIN_COMMIT);
5861 while ((line = strchr(line, ' '))) {
5862 line++;
5863 push_rev_graph(graph->parents, line);
5864 commit->has_parents = TRUE;
5865 }
5866 return TRUE;
5867 }
5869 if (!view->lines)
5870 return TRUE;
5871 commit = view->line[view->lines - 1].data;
5873 switch (type) {
5874 case LINE_PARENT:
5875 if (commit->has_parents)
5876 break;
5877 push_rev_graph(graph->parents, line + STRING_SIZE("parent "));
5878 break;
5880 case LINE_AUTHOR:
5881 parse_author_line(line + STRING_SIZE("author "),
5882 commit->author, sizeof(commit->author),
5883 &commit->time);
5884 update_rev_graph(view, graph);
5885 graph = graph->next;
5886 break;
5888 default:
5889 /* Fill in the commit title if it has not already been set. */
5890 if (commit->title[0])
5891 break;
5893 /* Require titles to start with a non-space character at the
5894 * offset used by git log. */
5895 if (strncmp(line, " ", 4))
5896 break;
5897 line += 4;
5898 /* Well, if the title starts with a whitespace character,
5899 * try to be forgiving. Otherwise we end up with no title. */
5900 while (isspace(*line))
5901 line++;
5902 if (*line == '\0')
5903 break;
5904 /* FIXME: More graceful handling of titles; append "..." to
5905 * shortened titles, etc. */
5907 string_expand(commit->title, sizeof(commit->title), line, 1);
5908 view->line[view->lines - 1].dirty = 1;
5909 }
5911 return TRUE;
5912 }
5914 static enum request
5915 main_request(struct view *view, enum request request, struct line *line)
5916 {
5917 enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
5919 switch (request) {
5920 case REQ_ENTER:
5921 open_view(view, REQ_VIEW_DIFF, flags);
5922 break;
5923 case REQ_REFRESH:
5924 load_refs();
5925 open_view(view, REQ_VIEW_MAIN, OPEN_REFRESH);
5926 break;
5927 default:
5928 return request;
5929 }
5931 return REQ_NONE;
5932 }
5934 static bool
5935 grep_refs(struct ref **refs, regex_t *regex)
5936 {
5937 regmatch_t pmatch;
5938 size_t i = 0;
5940 if (!refs)
5941 return FALSE;
5942 do {
5943 if (regexec(regex, refs[i]->name, 1, &pmatch, 0) != REG_NOMATCH)
5944 return TRUE;
5945 } while (refs[i++]->next);
5947 return FALSE;
5948 }
5950 static bool
5951 main_grep(struct view *view, struct line *line)
5952 {
5953 struct commit *commit = line->data;
5954 enum { S_TITLE, S_AUTHOR, S_DATE, S_REFS, S_END } state;
5955 char buf[DATE_COLS + 1];
5956 regmatch_t pmatch;
5958 for (state = S_TITLE; state < S_END; state++) {
5959 char *text;
5961 switch (state) {
5962 case S_TITLE: text = commit->title; break;
5963 case S_AUTHOR:
5964 if (!opt_author)
5965 continue;
5966 text = commit->author;
5967 break;
5968 case S_DATE:
5969 if (!opt_date)
5970 continue;
5971 if (!strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time))
5972 continue;
5973 text = buf;
5974 break;
5975 case S_REFS:
5976 if (!opt_show_refs)
5977 continue;
5978 if (grep_refs(commit->refs, view->regex) == TRUE)
5979 return TRUE;
5980 continue;
5981 default:
5982 return FALSE;
5983 }
5985 if (regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
5986 return TRUE;
5987 }
5989 return FALSE;
5990 }
5992 static void
5993 main_select(struct view *view, struct line *line)
5994 {
5995 struct commit *commit = line->data;
5997 string_copy_rev(view->ref, commit->id);
5998 string_copy_rev(ref_commit, view->ref);
5999 }
6001 static struct view_ops main_ops = {
6002 "commit",
6003 main_argv,
6004 NULL,
6005 main_read,
6006 main_draw,
6007 main_request,
6008 main_grep,
6009 main_select,
6010 };
6013 /*
6014 * Unicode / UTF-8 handling
6015 *
6016 * NOTE: Much of the following code for dealing with Unicode is derived from
6017 * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
6018 * src/intl/charset.c from the UTF-8 branch commit elinks-0.11.0-g31f2c28.
6019 */
6021 static inline int
6022 unicode_width(unsigned long c)
6023 {
6024 if (c >= 0x1100 &&
6025 (c <= 0x115f /* Hangul Jamo */
6026 || c == 0x2329
6027 || c == 0x232a
6028 || (c >= 0x2e80 && c <= 0xa4cf && c != 0x303f)
6029 /* CJK ... Yi */
6030 || (c >= 0xac00 && c <= 0xd7a3) /* Hangul Syllables */
6031 || (c >= 0xf900 && c <= 0xfaff) /* CJK Compatibility Ideographs */
6032 || (c >= 0xfe30 && c <= 0xfe6f) /* CJK Compatibility Forms */
6033 || (c >= 0xff00 && c <= 0xff60) /* Fullwidth Forms */
6034 || (c >= 0xffe0 && c <= 0xffe6)
6035 || (c >= 0x20000 && c <= 0x2fffd)
6036 || (c >= 0x30000 && c <= 0x3fffd)))
6037 return 2;
6039 if (c == '\t')
6040 return opt_tab_size;
6042 return 1;
6043 }
6045 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
6046 * Illegal bytes are set one. */
6047 static const unsigned char utf8_bytes[256] = {
6048 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,
6049 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,
6050 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,
6051 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,
6052 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,
6053 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,
6054 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,
6055 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,
6056 };
6058 /* Decode UTF-8 multi-byte representation into a Unicode character. */
6059 static inline unsigned long
6060 utf8_to_unicode(const char *string, size_t length)
6061 {
6062 unsigned long unicode;
6064 switch (length) {
6065 case 1:
6066 unicode = string[0];
6067 break;
6068 case 2:
6069 unicode = (string[0] & 0x1f) << 6;
6070 unicode += (string[1] & 0x3f);
6071 break;
6072 case 3:
6073 unicode = (string[0] & 0x0f) << 12;
6074 unicode += ((string[1] & 0x3f) << 6);
6075 unicode += (string[2] & 0x3f);
6076 break;
6077 case 4:
6078 unicode = (string[0] & 0x0f) << 18;
6079 unicode += ((string[1] & 0x3f) << 12);
6080 unicode += ((string[2] & 0x3f) << 6);
6081 unicode += (string[3] & 0x3f);
6082 break;
6083 case 5:
6084 unicode = (string[0] & 0x0f) << 24;
6085 unicode += ((string[1] & 0x3f) << 18);
6086 unicode += ((string[2] & 0x3f) << 12);
6087 unicode += ((string[3] & 0x3f) << 6);
6088 unicode += (string[4] & 0x3f);
6089 break;
6090 case 6:
6091 unicode = (string[0] & 0x01) << 30;
6092 unicode += ((string[1] & 0x3f) << 24);
6093 unicode += ((string[2] & 0x3f) << 18);
6094 unicode += ((string[3] & 0x3f) << 12);
6095 unicode += ((string[4] & 0x3f) << 6);
6096 unicode += (string[5] & 0x3f);
6097 break;
6098 default:
6099 die("Invalid Unicode length");
6100 }
6102 /* Invalid characters could return the special 0xfffd value but NUL
6103 * should be just as good. */
6104 return unicode > 0xffff ? 0 : unicode;
6105 }
6107 /* Calculates how much of string can be shown within the given maximum width
6108 * and sets trimmed parameter to non-zero value if all of string could not be
6109 * shown. If the reserve flag is TRUE, it will reserve at least one
6110 * trailing character, which can be useful when drawing a delimiter.
6111 *
6112 * Returns the number of bytes to output from string to satisfy max_width. */
6113 static size_t
6114 utf8_length(const char **start, size_t skip, int *width, size_t max_width, int *trimmed, bool reserve)
6115 {
6116 const char *string = *start;
6117 const char *end = strchr(string, '\0');
6118 unsigned char last_bytes = 0;
6119 size_t last_ucwidth = 0;
6121 *width = 0;
6122 *trimmed = 0;
6124 while (string < end) {
6125 int c = *(unsigned char *) string;
6126 unsigned char bytes = utf8_bytes[c];
6127 size_t ucwidth;
6128 unsigned long unicode;
6130 if (string + bytes > end)
6131 break;
6133 /* Change representation to figure out whether
6134 * it is a single- or double-width character. */
6136 unicode = utf8_to_unicode(string, bytes);
6137 /* FIXME: Graceful handling of invalid Unicode character. */
6138 if (!unicode)
6139 break;
6141 ucwidth = unicode_width(unicode);
6142 if (skip > 0) {
6143 skip -= ucwidth <= skip ? ucwidth : skip;
6144 *start += bytes;
6145 }
6146 *width += ucwidth;
6147 if (*width > max_width) {
6148 *trimmed = 1;
6149 *width -= ucwidth;
6150 if (reserve && *width == max_width) {
6151 string -= last_bytes;
6152 *width -= last_ucwidth;
6153 }
6154 break;
6155 }
6157 string += bytes;
6158 last_bytes = ucwidth ? bytes : 0;
6159 last_ucwidth = ucwidth;
6160 }
6162 return string - *start;
6163 }
6166 /*
6167 * Status management
6168 */
6170 /* Whether or not the curses interface has been initialized. */
6171 static bool cursed = FALSE;
6173 /* Terminal hacks and workarounds. */
6174 static bool use_scroll_redrawwin;
6175 static bool use_scroll_status_wclear;
6177 /* The status window is used for polling keystrokes. */
6178 static WINDOW *status_win;
6180 /* Reading from the prompt? */
6181 static bool input_mode = FALSE;
6183 static bool status_empty = FALSE;
6185 /* Update status and title window. */
6186 static void
6187 report(const char *msg, ...)
6188 {
6189 struct view *view = display[current_view];
6191 if (input_mode)
6192 return;
6194 if (!view) {
6195 char buf[SIZEOF_STR];
6196 va_list args;
6198 va_start(args, msg);
6199 if (vsnprintf(buf, sizeof(buf), msg, args) >= sizeof(buf)) {
6200 buf[sizeof(buf) - 1] = 0;
6201 buf[sizeof(buf) - 2] = '.';
6202 buf[sizeof(buf) - 3] = '.';
6203 buf[sizeof(buf) - 4] = '.';
6204 }
6205 va_end(args);
6206 die("%s", buf);
6207 }
6209 if (!status_empty || *msg) {
6210 va_list args;
6212 va_start(args, msg);
6214 wmove(status_win, 0, 0);
6215 if (view->has_scrolled && use_scroll_status_wclear)
6216 wclear(status_win);
6217 if (*msg) {
6218 vwprintw(status_win, msg, args);
6219 status_empty = FALSE;
6220 } else {
6221 status_empty = TRUE;
6222 }
6223 wclrtoeol(status_win);
6224 wnoutrefresh(status_win);
6226 va_end(args);
6227 }
6229 update_view_title(view);
6230 }
6232 /* Controls when nodelay should be in effect when polling user input. */
6233 static void
6234 set_nonblocking_input(bool loading)
6235 {
6236 static unsigned int loading_views;
6238 if ((loading == FALSE && loading_views-- == 1) ||
6239 (loading == TRUE && loading_views++ == 0))
6240 nodelay(status_win, loading);
6241 }
6243 static void
6244 init_display(void)
6245 {
6246 const char *term;
6247 int x, y;
6249 /* Initialize the curses library */
6250 if (isatty(STDIN_FILENO)) {
6251 cursed = !!initscr();
6252 opt_tty = stdin;
6253 } else {
6254 /* Leave stdin and stdout alone when acting as a pager. */
6255 opt_tty = fopen("/dev/tty", "r+");
6256 if (!opt_tty)
6257 die("Failed to open /dev/tty");
6258 cursed = !!newterm(NULL, opt_tty, opt_tty);
6259 }
6261 if (!cursed)
6262 die("Failed to initialize curses");
6264 nonl(); /* Disable conversion and detect newlines from input. */
6265 cbreak(); /* Take input chars one at a time, no wait for \n */
6266 noecho(); /* Don't echo input */
6267 leaveok(stdscr, FALSE);
6269 if (has_colors())
6270 init_colors();
6272 getmaxyx(stdscr, y, x);
6273 status_win = newwin(1, 0, y - 1, 0);
6274 if (!status_win)
6275 die("Failed to create status window");
6277 /* Enable keyboard mapping */
6278 keypad(status_win, TRUE);
6279 wbkgdset(status_win, get_line_attr(LINE_STATUS));
6281 TABSIZE = opt_tab_size;
6282 if (opt_line_graphics) {
6283 line_graphics[LINE_GRAPHIC_VLINE] = ACS_VLINE;
6284 }
6286 term = getenv("XTERM_VERSION") ? NULL : getenv("COLORTERM");
6287 if (term && !strcmp(term, "gnome-terminal")) {
6288 /* In the gnome-terminal-emulator, the message from
6289 * scrolling up one line when impossible followed by
6290 * scrolling down one line causes corruption of the
6291 * status line. This is fixed by calling wclear. */
6292 use_scroll_status_wclear = TRUE;
6293 use_scroll_redrawwin = FALSE;
6295 } else if (term && !strcmp(term, "xrvt-xpm")) {
6296 /* No problems with full optimizations in xrvt-(unicode)
6297 * and aterm. */
6298 use_scroll_status_wclear = use_scroll_redrawwin = FALSE;
6300 } else {
6301 /* When scrolling in (u)xterm the last line in the
6302 * scrolling direction will update slowly. */
6303 use_scroll_redrawwin = TRUE;
6304 use_scroll_status_wclear = FALSE;
6305 }
6306 }
6308 static int
6309 get_input(int prompt_position)
6310 {
6311 struct view *view;
6312 int i, key, cursor_y, cursor_x;
6314 if (prompt_position)
6315 input_mode = TRUE;
6317 while (TRUE) {
6318 foreach_view (view, i) {
6319 update_view(view);
6320 if (view_is_displayed(view) && view->has_scrolled &&
6321 use_scroll_redrawwin)
6322 redrawwin(view->win);
6323 view->has_scrolled = FALSE;
6324 }
6326 /* Update the cursor position. */
6327 if (prompt_position) {
6328 getbegyx(status_win, cursor_y, cursor_x);
6329 cursor_x = prompt_position;
6330 } else {
6331 view = display[current_view];
6332 getbegyx(view->win, cursor_y, cursor_x);
6333 cursor_x = view->width - 1;
6334 cursor_y += view->lineno - view->offset;
6335 }
6336 setsyx(cursor_y, cursor_x);
6338 /* Refresh, accept single keystroke of input */
6339 doupdate();
6340 key = wgetch(status_win);
6342 /* wgetch() with nodelay() enabled returns ERR when
6343 * there's no input. */
6344 if (key == ERR) {
6346 } else if (key == KEY_RESIZE) {
6347 int height, width;
6349 getmaxyx(stdscr, height, width);
6351 wresize(status_win, 1, width);
6352 mvwin(status_win, height - 1, 0);
6353 wnoutrefresh(status_win);
6354 resize_display();
6355 redraw_display(TRUE);
6357 } else {
6358 input_mode = FALSE;
6359 return key;
6360 }
6361 }
6362 }
6364 static char *
6365 prompt_input(const char *prompt, input_handler handler, void *data)
6366 {
6367 enum input_status status = INPUT_OK;
6368 static char buf[SIZEOF_STR];
6369 size_t pos = 0;
6371 buf[pos] = 0;
6373 while (status == INPUT_OK || status == INPUT_SKIP) {
6374 int key;
6376 mvwprintw(status_win, 0, 0, "%s%.*s", prompt, pos, buf);
6377 wclrtoeol(status_win);
6379 key = get_input(pos + 1);
6380 switch (key) {
6381 case KEY_RETURN:
6382 case KEY_ENTER:
6383 case '\n':
6384 status = pos ? INPUT_STOP : INPUT_CANCEL;
6385 break;
6387 case KEY_BACKSPACE:
6388 if (pos > 0)
6389 buf[--pos] = 0;
6390 else
6391 status = INPUT_CANCEL;
6392 break;
6394 case KEY_ESC:
6395 status = INPUT_CANCEL;
6396 break;
6398 default:
6399 if (pos >= sizeof(buf)) {
6400 report("Input string too long");
6401 return NULL;
6402 }
6404 status = handler(data, buf, key);
6405 if (status == INPUT_OK)
6406 buf[pos++] = (char) key;
6407 }
6408 }
6410 /* Clear the status window */
6411 status_empty = FALSE;
6412 report("");
6414 if (status == INPUT_CANCEL)
6415 return NULL;
6417 buf[pos++] = 0;
6419 return buf;
6420 }
6422 static enum input_status
6423 prompt_yesno_handler(void *data, char *buf, int c)
6424 {
6425 if (c == 'y' || c == 'Y')
6426 return INPUT_STOP;
6427 if (c == 'n' || c == 'N')
6428 return INPUT_CANCEL;
6429 return INPUT_SKIP;
6430 }
6432 static bool
6433 prompt_yesno(const char *prompt)
6434 {
6435 char prompt2[SIZEOF_STR];
6437 if (!string_format(prompt2, "%s [Yy/Nn]", prompt))
6438 return FALSE;
6440 return !!prompt_input(prompt2, prompt_yesno_handler, NULL);
6441 }
6443 static enum input_status
6444 read_prompt_handler(void *data, char *buf, int c)
6445 {
6446 return isprint(c) ? INPUT_OK : INPUT_SKIP;
6447 }
6449 static char *
6450 read_prompt(const char *prompt)
6451 {
6452 return prompt_input(prompt, read_prompt_handler, NULL);
6453 }
6455 /*
6456 * Repository properties
6457 */
6459 static struct ref *refs = NULL;
6460 static size_t refs_alloc = 0;
6461 static size_t refs_size = 0;
6463 /* Id <-> ref store */
6464 static struct ref ***id_refs = NULL;
6465 static size_t id_refs_alloc = 0;
6466 static size_t id_refs_size = 0;
6468 static int
6469 compare_refs(const void *ref1_, const void *ref2_)
6470 {
6471 const struct ref *ref1 = *(const struct ref **)ref1_;
6472 const struct ref *ref2 = *(const struct ref **)ref2_;
6474 if (ref1->tag != ref2->tag)
6475 return ref2->tag - ref1->tag;
6476 if (ref1->ltag != ref2->ltag)
6477 return ref2->ltag - ref2->ltag;
6478 if (ref1->head != ref2->head)
6479 return ref2->head - ref1->head;
6480 if (ref1->tracked != ref2->tracked)
6481 return ref2->tracked - ref1->tracked;
6482 if (ref1->remote != ref2->remote)
6483 return ref2->remote - ref1->remote;
6484 return strcmp(ref1->name, ref2->name);
6485 }
6487 static struct ref **
6488 get_refs(const char *id)
6489 {
6490 struct ref ***tmp_id_refs;
6491 struct ref **ref_list = NULL;
6492 size_t ref_list_alloc = 0;
6493 size_t ref_list_size = 0;
6494 size_t i;
6496 for (i = 0; i < id_refs_size; i++)
6497 if (!strcmp(id, id_refs[i][0]->id))
6498 return id_refs[i];
6500 tmp_id_refs = realloc_items(id_refs, &id_refs_alloc, id_refs_size + 1,
6501 sizeof(*id_refs));
6502 if (!tmp_id_refs)
6503 return NULL;
6505 id_refs = tmp_id_refs;
6507 for (i = 0; i < refs_size; i++) {
6508 struct ref **tmp;
6510 if (strcmp(id, refs[i].id))
6511 continue;
6513 tmp = realloc_items(ref_list, &ref_list_alloc,
6514 ref_list_size + 1, sizeof(*ref_list));
6515 if (!tmp) {
6516 if (ref_list)
6517 free(ref_list);
6518 return NULL;
6519 }
6521 ref_list = tmp;
6522 ref_list[ref_list_size] = &refs[i];
6523 /* XXX: The properties of the commit chains ensures that we can
6524 * safely modify the shared ref. The repo references will
6525 * always be similar for the same id. */
6526 ref_list[ref_list_size]->next = 1;
6528 ref_list_size++;
6529 }
6531 if (ref_list) {
6532 qsort(ref_list, ref_list_size, sizeof(*ref_list), compare_refs);
6533 ref_list[ref_list_size - 1]->next = 0;
6534 id_refs[id_refs_size++] = ref_list;
6535 }
6537 return ref_list;
6538 }
6540 static int
6541 read_ref(char *id, size_t idlen, char *name, size_t namelen)
6542 {
6543 struct ref *ref;
6544 bool tag = FALSE;
6545 bool ltag = FALSE;
6546 bool remote = FALSE;
6547 bool tracked = FALSE;
6548 bool check_replace = FALSE;
6549 bool head = FALSE;
6551 if (!prefixcmp(name, "refs/tags/")) {
6552 if (!suffixcmp(name, namelen, "^{}")) {
6553 namelen -= 3;
6554 name[namelen] = 0;
6555 if (refs_size > 0 && refs[refs_size - 1].ltag == TRUE)
6556 check_replace = TRUE;
6557 } else {
6558 ltag = TRUE;
6559 }
6561 tag = TRUE;
6562 namelen -= STRING_SIZE("refs/tags/");
6563 name += STRING_SIZE("refs/tags/");
6565 } else if (!prefixcmp(name, "refs/remotes/")) {
6566 remote = TRUE;
6567 namelen -= STRING_SIZE("refs/remotes/");
6568 name += STRING_SIZE("refs/remotes/");
6569 tracked = !strcmp(opt_remote, name);
6571 } else if (!prefixcmp(name, "refs/heads/")) {
6572 namelen -= STRING_SIZE("refs/heads/");
6573 name += STRING_SIZE("refs/heads/");
6574 head = !strncmp(opt_head, name, namelen);
6576 } else if (!strcmp(name, "HEAD")) {
6577 string_ncopy(opt_head_rev, id, idlen);
6578 return OK;
6579 }
6581 if (check_replace && !strcmp(name, refs[refs_size - 1].name)) {
6582 /* it's an annotated tag, replace the previous SHA1 with the
6583 * resolved commit id; relies on the fact git-ls-remote lists
6584 * the commit id of an annotated tag right before the commit id
6585 * it points to. */
6586 refs[refs_size - 1].ltag = ltag;
6587 string_copy_rev(refs[refs_size - 1].id, id);
6589 return OK;
6590 }
6591 refs = realloc_items(refs, &refs_alloc, refs_size + 1, sizeof(*refs));
6592 if (!refs)
6593 return ERR;
6595 ref = &refs[refs_size++];
6596 ref->name = malloc(namelen + 1);
6597 if (!ref->name)
6598 return ERR;
6600 strncpy(ref->name, name, namelen);
6601 ref->name[namelen] = 0;
6602 ref->head = head;
6603 ref->tag = tag;
6604 ref->ltag = ltag;
6605 ref->remote = remote;
6606 ref->tracked = tracked;
6607 string_copy_rev(ref->id, id);
6609 return OK;
6610 }
6612 static int
6613 load_refs(void)
6614 {
6615 static const char *ls_remote_argv[SIZEOF_ARG] = {
6616 "git", "ls-remote", ".", NULL
6617 };
6618 static bool init = FALSE;
6620 if (!init) {
6621 argv_from_env(ls_remote_argv, "TIG_LS_REMOTE");
6622 init = TRUE;
6623 }
6625 if (!*opt_git_dir)
6626 return OK;
6628 while (refs_size > 0)
6629 free(refs[--refs_size].name);
6630 while (id_refs_size > 0)
6631 free(id_refs[--id_refs_size]);
6633 return run_io_load(ls_remote_argv, "\t", read_ref);
6634 }
6636 static void
6637 set_repo_config_option(char *name, char *value, int (*cmd)(int, const char **))
6638 {
6639 const char *argv[SIZEOF_ARG] = { name, "=" };
6640 int argc = 1 + (cmd == option_set_command);
6641 int error = ERR;
6643 if (!argv_from_string(argv, &argc, value))
6644 config_msg = "Too many option arguments";
6645 else
6646 error = cmd(argc, argv);
6648 if (error == ERR)
6649 warn("Option 'tig.%s': %s", name, config_msg);
6650 }
6652 static int
6653 read_repo_config_option(char *name, size_t namelen, char *value, size_t valuelen)
6654 {
6655 if (!strcmp(name, "i18n.commitencoding"))
6656 string_ncopy(opt_encoding, value, valuelen);
6658 if (!strcmp(name, "core.editor"))
6659 string_ncopy(opt_editor, value, valuelen);
6661 if (!prefixcmp(name, "tig.color."))
6662 set_repo_config_option(name + 10, value, option_color_command);
6664 else if (!prefixcmp(name, "tig.bind."))
6665 set_repo_config_option(name + 9, value, option_bind_command);
6667 else if (!prefixcmp(name, "tig."))
6668 set_repo_config_option(name + 4, value, option_set_command);
6670 /* branch.<head>.remote */
6671 if (*opt_head &&
6672 !strncmp(name, "branch.", 7) &&
6673 !strncmp(name + 7, opt_head, strlen(opt_head)) &&
6674 !strcmp(name + 7 + strlen(opt_head), ".remote"))
6675 string_ncopy(opt_remote, value, valuelen);
6677 if (*opt_head && *opt_remote &&
6678 !strncmp(name, "branch.", 7) &&
6679 !strncmp(name + 7, opt_head, strlen(opt_head)) &&
6680 !strcmp(name + 7 + strlen(opt_head), ".merge")) {
6681 size_t from = strlen(opt_remote);
6683 if (!prefixcmp(value, "refs/heads/")) {
6684 value += STRING_SIZE("refs/heads/");
6685 valuelen -= STRING_SIZE("refs/heads/");
6686 }
6688 if (!string_format_from(opt_remote, &from, "/%s", value))
6689 opt_remote[0] = 0;
6690 }
6692 return OK;
6693 }
6695 static int
6696 load_git_config(void)
6697 {
6698 const char *config_list_argv[] = { "git", GIT_CONFIG, "--list", NULL };
6700 return run_io_load(config_list_argv, "=", read_repo_config_option);
6701 }
6703 static int
6704 read_repo_info(char *name, size_t namelen, char *value, size_t valuelen)
6705 {
6706 if (!opt_git_dir[0]) {
6707 string_ncopy(opt_git_dir, name, namelen);
6709 } else if (opt_is_inside_work_tree == -1) {
6710 /* This can be 3 different values depending on the
6711 * version of git being used. If git-rev-parse does not
6712 * understand --is-inside-work-tree it will simply echo
6713 * the option else either "true" or "false" is printed.
6714 * Default to true for the unknown case. */
6715 opt_is_inside_work_tree = strcmp(name, "false") ? TRUE : FALSE;
6717 } else if (*name == '.') {
6718 string_ncopy(opt_cdup, name, namelen);
6720 } else {
6721 string_ncopy(opt_prefix, name, namelen);
6722 }
6724 return OK;
6725 }
6727 static int
6728 load_repo_info(void)
6729 {
6730 const char *head_argv[] = {
6731 "git", "symbolic-ref", "HEAD", NULL
6732 };
6733 const char *rev_parse_argv[] = {
6734 "git", "rev-parse", "--git-dir", "--is-inside-work-tree",
6735 "--show-cdup", "--show-prefix", NULL
6736 };
6738 if (run_io_buf(head_argv, opt_head, sizeof(opt_head))) {
6739 chomp_string(opt_head);
6740 if (!prefixcmp(opt_head, "refs/heads/")) {
6741 char *offset = opt_head + STRING_SIZE("refs/heads/");
6743 memmove(opt_head, offset, strlen(offset) + 1);
6744 }
6745 }
6747 return run_io_load(rev_parse_argv, "=", read_repo_info);
6748 }
6751 /*
6752 * Main
6753 */
6755 static const char usage[] =
6756 "tig " TIG_VERSION " (" __DATE__ ")\n"
6757 "\n"
6758 "Usage: tig [options] [revs] [--] [paths]\n"
6759 " or: tig show [options] [revs] [--] [paths]\n"
6760 " or: tig blame [rev] path\n"
6761 " or: tig status\n"
6762 " or: tig < [git command output]\n"
6763 "\n"
6764 "Options:\n"
6765 " -v, --version Show version and exit\n"
6766 " -h, --help Show help message and exit";
6768 static void __NORETURN
6769 quit(int sig)
6770 {
6771 /* XXX: Restore tty modes and let the OS cleanup the rest! */
6772 if (cursed)
6773 endwin();
6774 exit(0);
6775 }
6777 static void __NORETURN
6778 die(const char *err, ...)
6779 {
6780 va_list args;
6782 endwin();
6784 va_start(args, err);
6785 fputs("tig: ", stderr);
6786 vfprintf(stderr, err, args);
6787 fputs("\n", stderr);
6788 va_end(args);
6790 exit(1);
6791 }
6793 static void
6794 warn(const char *msg, ...)
6795 {
6796 va_list args;
6798 va_start(args, msg);
6799 fputs("tig warning: ", stderr);
6800 vfprintf(stderr, msg, args);
6801 fputs("\n", stderr);
6802 va_end(args);
6803 }
6805 static enum request
6806 parse_options(int argc, const char *argv[])
6807 {
6808 enum request request = REQ_VIEW_MAIN;
6809 const char *subcommand;
6810 bool seen_dashdash = FALSE;
6811 /* XXX: This is vulnerable to the user overriding options
6812 * required for the main view parser. */
6813 const char *custom_argv[SIZEOF_ARG] = {
6814 "git", "log", "--no-color", "--pretty=raw", "--parents",
6815 "--topo-order", NULL
6816 };
6817 int i, j = 6;
6819 if (!isatty(STDIN_FILENO)) {
6820 io_open(&VIEW(REQ_VIEW_PAGER)->io, "");
6821 return REQ_VIEW_PAGER;
6822 }
6824 if (argc <= 1)
6825 return REQ_NONE;
6827 subcommand = argv[1];
6828 if (!strcmp(subcommand, "status")) {
6829 if (argc > 2)
6830 warn("ignoring arguments after `%s'", subcommand);
6831 return REQ_VIEW_STATUS;
6833 } else if (!strcmp(subcommand, "blame")) {
6834 if (argc <= 2 || argc > 4)
6835 die("invalid number of options to blame\n\n%s", usage);
6837 i = 2;
6838 if (argc == 4) {
6839 string_ncopy(opt_ref, argv[i], strlen(argv[i]));
6840 i++;
6841 }
6843 string_ncopy(opt_file, argv[i], strlen(argv[i]));
6844 return REQ_VIEW_BLAME;
6846 } else if (!strcmp(subcommand, "show")) {
6847 request = REQ_VIEW_DIFF;
6849 } else {
6850 subcommand = NULL;
6851 }
6853 if (subcommand) {
6854 custom_argv[1] = subcommand;
6855 j = 2;
6856 }
6858 for (i = 1 + !!subcommand; i < argc; i++) {
6859 const char *opt = argv[i];
6861 if (seen_dashdash || !strcmp(opt, "--")) {
6862 seen_dashdash = TRUE;
6864 } else if (!strcmp(opt, "-v") || !strcmp(opt, "--version")) {
6865 printf("tig version %s\n", TIG_VERSION);
6866 quit(0);
6868 } else if (!strcmp(opt, "-h") || !strcmp(opt, "--help")) {
6869 printf("%s\n", usage);
6870 quit(0);
6871 }
6873 custom_argv[j++] = opt;
6874 if (j >= ARRAY_SIZE(custom_argv))
6875 die("command too long");
6876 }
6878 if (!prepare_update(VIEW(request), custom_argv, NULL, FORMAT_NONE))
6879 die("Failed to format arguments");
6881 return request;
6882 }
6884 int
6885 main(int argc, const char *argv[])
6886 {
6887 enum request request = parse_options(argc, argv);
6888 struct view *view;
6889 size_t i;
6891 signal(SIGINT, quit);
6893 if (setlocale(LC_ALL, "")) {
6894 char *codeset = nl_langinfo(CODESET);
6896 string_ncopy(opt_codeset, codeset, strlen(codeset));
6897 }
6899 if (load_repo_info() == ERR)
6900 die("Failed to load repo info.");
6902 if (load_options() == ERR)
6903 die("Failed to load user config.");
6905 if (load_git_config() == ERR)
6906 die("Failed to load repo config.");
6908 /* Require a git repository unless when running in pager mode. */
6909 if (!opt_git_dir[0] && request != REQ_VIEW_PAGER)
6910 die("Not a git repository");
6912 if (*opt_encoding && strcasecmp(opt_encoding, "UTF-8"))
6913 opt_utf8 = FALSE;
6915 if (*opt_codeset && strcmp(opt_codeset, opt_encoding)) {
6916 opt_iconv = iconv_open(opt_codeset, opt_encoding);
6917 if (opt_iconv == ICONV_NONE)
6918 die("Failed to initialize character set conversion");
6919 }
6921 if (load_refs() == ERR)
6922 die("Failed to load refs.");
6924 foreach_view (view, i)
6925 argv_from_env(view->ops->argv, view->cmd_env);
6927 init_display();
6929 if (request != REQ_NONE)
6930 open_view(NULL, request, OPEN_PREPARED);
6931 request = request == REQ_NONE ? REQ_VIEW_MAIN : REQ_NONE;
6933 while (view_driver(display[current_view], request)) {
6934 int key = get_input(0);
6936 view = display[current_view];
6937 request = get_keybinding(view->keymap, key);
6939 /* Some low-level request handling. This keeps access to
6940 * status_win restricted. */
6941 switch (request) {
6942 case REQ_PROMPT:
6943 {
6944 char *cmd = read_prompt(":");
6946 if (cmd) {
6947 struct view *next = VIEW(REQ_VIEW_PAGER);
6948 const char *argv[SIZEOF_ARG] = { "git" };
6949 int argc = 1;
6951 /* When running random commands, initially show the
6952 * command in the title. However, it maybe later be
6953 * overwritten if a commit line is selected. */
6954 string_ncopy(next->ref, cmd, strlen(cmd));
6956 if (!argv_from_string(argv, &argc, cmd)) {
6957 report("Too many arguments");
6958 } else if (!prepare_update(next, argv, NULL, FORMAT_DASH)) {
6959 report("Failed to format command");
6960 } else {
6961 open_view(view, REQ_VIEW_PAGER, OPEN_PREPARED);
6962 }
6963 }
6965 request = REQ_NONE;
6966 break;
6967 }
6968 case REQ_SEARCH:
6969 case REQ_SEARCH_BACK:
6970 {
6971 const char *prompt = request == REQ_SEARCH ? "/" : "?";
6972 char *search = read_prompt(prompt);
6974 if (search)
6975 string_ncopy(opt_search, search, strlen(search));
6976 else if (*opt_search)
6977 request = request == REQ_SEARCH ?
6978 REQ_FIND_NEXT :
6979 REQ_FIND_PREV;
6980 else
6981 request = REQ_NONE;
6982 break;
6983 }
6984 default:
6985 break;
6986 }
6987 }
6989 quit(0);
6991 return 0;
6992 }