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