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