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