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