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