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