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