~mdw / tig / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Obsolete the cherry-pick action and define as builtin external command
[tig] / tig.c
1 /* Copyright (c) 2006-2007 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/stat.h>
36 #include <unistd.h>
37 #include <time.h>
38
39 #include <regex.h>
40
41 #include <locale.h>
42 #include <langinfo.h>
43 #include <iconv.h>
44
45 #include <curses.h>
46
47 #if __GNUC__ >= 3
48 #define __NORETURN __attribute__((__noreturn__))
49 #else
50 #define __NORETURN
51 #endif
52
53 static void __NORETURN die(const char *err, ...);
54 static void report(const char *msg, ...);
55 static int read_properties(FILE *pipe, const char *separators, int (*read)(char *, size_t, char *, size_t));
56 static void set_nonblocking_input(bool loading);
57 static size_t utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed);
58
59 #define ABS(x) ((x) >= 0 ? (x) : -(x))
60 #define MIN(x, y) ((x) < (y) ? (x) : (y))
61
62 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
63 #define STRING_SIZE(x) (sizeof(x) - 1)
64
65 #define SIZEOF_STR 1024 /* Default string size. */
66 #define SIZEOF_REF 256 /* Size of symbolic or SHA1 ID. */
67 #define SIZEOF_REV 41 /* Holds a SHA-1 and an ending NUL */
68
69 /* Revision graph */
70
71 #define REVGRAPH_INIT 'I'
72 #define REVGRAPH_MERGE 'M'
73 #define REVGRAPH_BRANCH '+'
74 #define REVGRAPH_COMMIT '*'
75 #define REVGRAPH_LINE '|'
76
77 #define SIZEOF_REVGRAPH 19 /* Size of revision ancestry graphics. */
78
79 /* This color name can be used to refer to the default term colors. */
80 #define COLOR_DEFAULT (-1)
81
82 #define ICONV_NONE ((iconv_t) -1)
83 #ifndef ICONV_CONST
84 #define ICONV_CONST /* nothing */
85 #endif
86
87 /* The format and size of the date column in the main view. */
88 #define DATE_FORMAT "%Y-%m-%d %H:%M"
89 #define DATE_COLS STRING_SIZE("2006-04-29 14:21 ")
90
91 #define AUTHOR_COLS 20
92
93 /* The default interval between line numbers. */
94 #define NUMBER_INTERVAL 1
95
96 #define TABSIZE 8
97
98 #define SCALE_SPLIT_VIEW(height) ((height) * 2 / 3)
99
100 #ifndef GIT_CONFIG
101 #define GIT_CONFIG "git config"
102 #endif
103
104 #define TIG_LS_REMOTE \
105 "git ls-remote $(git rev-parse --git-dir) 2>/dev/null"
106
107 #define TIG_DIFF_CMD \
108 "git show --root --patch-with-stat --find-copies-harder -B -C %s 2>/dev/null"
109
110 #define TIG_LOG_CMD \
111 "git log --cc --stat -n100 %s 2>/dev/null"
112
113 #define TIG_MAIN_CMD \
114 "git log --topo-order --pretty=raw %s 2>/dev/null"
115
116 #define TIG_TREE_CMD \
117 "git ls-tree %s %s"
118
119 #define TIG_BLOB_CMD \
120 "git cat-file blob %s"
121
122 /* XXX: Needs to be defined to the empty string. */
123 #define TIG_HELP_CMD ""
124 #define TIG_PAGER_CMD ""
125 #define TIG_STATUS_CMD ""
126 #define TIG_STAGE_CMD ""
127
128 /* Some ascii-shorthands fitted into the ncurses namespace. */
129 #define KEY_TAB '\t'
130 #define KEY_RETURN '\r'
131 #define KEY_ESC 27
132
133
134 struct ref {
135 char *name; /* Ref name; tag or head names are shortened. */
136 char id[SIZEOF_REV]; /* Commit SHA1 ID */
137 unsigned int tag:1; /* Is it a tag? */
138 unsigned int remote:1; /* Is it a remote ref? */
139 unsigned int next:1; /* For ref lists: are there more refs? */
140 };
141
142 static struct ref **get_refs(char *id);
143
144 struct int_map {
145 const char *name;
146 int namelen;
147 int value;
148 };
149
150 static int
151 set_from_int_map(struct int_map *map, size_t map_size,
152 int *value, const char *name, int namelen)
153 {
154
155 int i;
156
157 for (i = 0; i < map_size; i++)
158 if (namelen == map[i].namelen &&
159 !strncasecmp(name, map[i].name, namelen)) {
160 *value = map[i].value;
161 return OK;
162 }
163
164 return ERR;
165 }
166
167
168 /*
169 * String helpers
170 */
171
172 static inline void
173 string_ncopy_do(char *dst, size_t dstlen, const char *src, size_t srclen)
174 {
175 if (srclen > dstlen - 1)
176 srclen = dstlen - 1;
177
178 strncpy(dst, src, srclen);
179 dst[srclen] = 0;
180 }
181
182 /* Shorthands for safely copying into a fixed buffer. */
183
184 #define string_copy(dst, src) \
185 string_ncopy_do(dst, sizeof(dst), src, sizeof(src))
186
187 #define string_ncopy(dst, src, srclen) \
188 string_ncopy_do(dst, sizeof(dst), src, srclen)
189
190 #define string_copy_rev(dst, src) \
191 string_ncopy_do(dst, SIZEOF_REV, src, SIZEOF_REV - 1)
192
193 #define string_add(dst, from, src) \
194 string_ncopy_do(dst + (from), sizeof(dst) - (from), src, sizeof(src))
195
196 static char *
197 chomp_string(char *name)
198 {
199 int namelen;
200
201 while (isspace(*name))
202 name++;
203
204 namelen = strlen(name) - 1;
205 while (namelen > 0 && isspace(name[namelen]))
206 name[namelen--] = 0;
207
208 return name;
209 }
210
211 static bool
212 string_nformat(char *buf, size_t bufsize, size_t *bufpos, const char *fmt, ...)
213 {
214 va_list args;
215 size_t pos = bufpos ? *bufpos : 0;
216
217 va_start(args, fmt);
218 pos += vsnprintf(buf + pos, bufsize - pos, fmt, args);
219 va_end(args);
220
221 if (bufpos)
222 *bufpos = pos;
223
224 return pos >= bufsize ? FALSE : TRUE;
225 }
226
227 #define string_format(buf, fmt, args...) \
228 string_nformat(buf, sizeof(buf), NULL, fmt, args)
229
230 #define string_format_from(buf, from, fmt, args...) \
231 string_nformat(buf, sizeof(buf), from, fmt, args)
232
233 static int
234 string_enum_compare(const char *str1, const char *str2, int len)
235 {
236 size_t i;
237
238 #define string_enum_sep(x) ((x) == '-' || (x) == '_' || (x) == '.')
239
240 /* Diff-Header == DIFF_HEADER */
241 for (i = 0; i < len; i++) {
242 if (toupper(str1[i]) == toupper(str2[i]))
243 continue;
244
245 if (string_enum_sep(str1[i]) &&
246 string_enum_sep(str2[i]))
247 continue;
248
249 return str1[i] - str2[i];
250 }
251
252 return 0;
253 }
254
255 /* Shell quoting
256 *
257 * NOTE: The following is a slightly modified copy of the git project's shell
258 * quoting routines found in the quote.c file.
259 *
260 * Help to copy the thing properly quoted for the shell safety. any single
261 * quote is replaced with '\'', any exclamation point is replaced with '\!',
262 * and the whole thing is enclosed in a
263 *
264 * E.g.
265 * original sq_quote result
266 * name ==> name ==> 'name'
267 * a b ==> a b ==> 'a b'
268 * a'b ==> a'\''b ==> 'a'\''b'
269 * a!b ==> a'\!'b ==> 'a'\!'b'
270 */
271
272 static size_t
273 sq_quote(char buf[SIZEOF_STR], size_t bufsize, const char *src)
274 {
275 char c;
276
277 #define BUFPUT(x) do { if (bufsize < SIZEOF_STR) buf[bufsize++] = (x); } while (0)
278
279 BUFPUT('\'');
280 while ((c = *src++)) {
281 if (c == '\'' || c == '!') {
282 BUFPUT('\'');
283 BUFPUT('\\');
284 BUFPUT(c);
285 BUFPUT('\'');
286 } else {
287 BUFPUT(c);
288 }
289 }
290 BUFPUT('\'');
291
292 if (bufsize < SIZEOF_STR)
293 buf[bufsize] = 0;
294
295 return bufsize;
296 }
297
298
299 /*
300 * User requests
301 */
302
303 #define REQ_INFO \
304 /* XXX: Keep the view request first and in sync with views[]. */ \
305 REQ_GROUP("View switching") \
306 REQ_(VIEW_MAIN, "Show main view"), \
307 REQ_(VIEW_DIFF, "Show diff view"), \
308 REQ_(VIEW_LOG, "Show log view"), \
309 REQ_(VIEW_TREE, "Show tree view"), \
310 REQ_(VIEW_BLOB, "Show blob view"), \
311 REQ_(VIEW_HELP, "Show help page"), \
312 REQ_(VIEW_PAGER, "Show pager view"), \
313 REQ_(VIEW_STATUS, "Show status view"), \
314 REQ_(VIEW_STAGE, "Show stage view"), \
315 \
316 REQ_GROUP("View manipulation") \
317 REQ_(ENTER, "Enter current line and scroll"), \
318 REQ_(NEXT, "Move to next"), \
319 REQ_(PREVIOUS, "Move to previous"), \
320 REQ_(VIEW_NEXT, "Move focus to next view"), \
321 REQ_(REFRESH, "Reload and refresh"), \
322 REQ_(VIEW_CLOSE, "Close the current view"), \
323 REQ_(QUIT, "Close all views and quit"), \
324 \
325 REQ_GROUP("Cursor navigation") \
326 REQ_(MOVE_UP, "Move cursor one line up"), \
327 REQ_(MOVE_DOWN, "Move cursor one line down"), \
328 REQ_(MOVE_PAGE_DOWN, "Move cursor one page down"), \
329 REQ_(MOVE_PAGE_UP, "Move cursor one page up"), \
330 REQ_(MOVE_FIRST_LINE, "Move cursor to first line"), \
331 REQ_(MOVE_LAST_LINE, "Move cursor to last line"), \
332 \
333 REQ_GROUP("Scrolling") \
334 REQ_(SCROLL_LINE_UP, "Scroll one line up"), \
335 REQ_(SCROLL_LINE_DOWN, "Scroll one line down"), \
336 REQ_(SCROLL_PAGE_UP, "Scroll one page up"), \
337 REQ_(SCROLL_PAGE_DOWN, "Scroll one page down"), \
338 \
339 REQ_GROUP("Searching") \
340 REQ_(SEARCH, "Search the view"), \
341 REQ_(SEARCH_BACK, "Search backwards in the view"), \
342 REQ_(FIND_NEXT, "Find next search match"), \
343 REQ_(FIND_PREV, "Find previous search match"), \
344 \
345 REQ_GROUP("Misc") \
346 REQ_(PROMPT, "Bring up the prompt"), \
347 REQ_(SCREEN_REDRAW, "Redraw the screen"), \
348 REQ_(SCREEN_RESIZE, "Resize the screen"), \
349 REQ_(SHOW_VERSION, "Show version information"), \
350 REQ_(STOP_LOADING, "Stop all loading views"), \
351 REQ_(TOGGLE_LINENO, "Toggle line numbers"), \
352 REQ_(TOGGLE_REV_GRAPH, "Toggle revision graph visualization"), \
353 REQ_(STATUS_UPDATE, "Update file status"), \
354 REQ_(STATUS_MERGE, "Merge file using external tool"), \
355 REQ_(EDIT, "Open in editor"), \
356 REQ_(NONE, "Do nothing")
357
358
359 /* User action requests. */
360 enum request {
361 #define REQ_GROUP(help)
362 #define REQ_(req, help) REQ_##req
363
364 /* Offset all requests to avoid conflicts with ncurses getch values. */
365 REQ_OFFSET = KEY_MAX + 1,
366 REQ_INFO
367
368 #undef REQ_GROUP
369 #undef REQ_
370 };
371
372 struct request_info {
373 enum request request;
374 char *name;
375 int namelen;
376 char *help;
377 };
378
379 static struct request_info req_info[] = {
380 #define REQ_GROUP(help) { 0, NULL, 0, (help) },
381 #define REQ_(req, help) { REQ_##req, (#req), STRING_SIZE(#req), (help) }
382 REQ_INFO
383 #undef REQ_GROUP
384 #undef REQ_
385 };
386
387 static enum request
388 get_request(const char *name)
389 {
390 int namelen = strlen(name);
391 int i;
392
393 for (i = 0; i < ARRAY_SIZE(req_info); i++)
394 if (req_info[i].namelen == namelen &&
395 !string_enum_compare(req_info[i].name, name, namelen))
396 return req_info[i].request;
397
398 return REQ_NONE;
399 }
400
401
402 /*
403 * Options
404 */
405
406 static const char usage[] =
407 "tig " TIG_VERSION " (" __DATE__ ")\n"
408 "\n"
409 "Usage: tig [options]\n"
410 " or: tig [options] [--] [git log options]\n"
411 " or: tig [options] log [git log options]\n"
412 " or: tig [options] diff [git diff options]\n"
413 " or: tig [options] show [git show options]\n"
414 " or: tig [options] < [git command output]\n"
415 "\n"
416 "Options:\n"
417 " -l Start up in log view\n"
418 " -d Start up in diff view\n"
419 " -S Start up in status view\n"
420 " -n[I], --line-number[=I] Show line numbers with given interval\n"
421 " -b[N], --tab-size[=N] Set number of spaces for tab expansion\n"
422 " -- Mark end of tig options\n"
423 " -v, --version Show version and exit\n"
424 " -h, --help Show help message and exit\n";
425
426 /* Option and state variables. */
427 static bool opt_line_number = FALSE;
428 static bool opt_rev_graph = FALSE;
429 static int opt_num_interval = NUMBER_INTERVAL;
430 static int opt_tab_size = TABSIZE;
431 static enum request opt_request = REQ_VIEW_MAIN;
432 static char opt_cmd[SIZEOF_STR] = "";
433 static char opt_path[SIZEOF_STR] = "";
434 static FILE *opt_pipe = NULL;
435 static char opt_encoding[20] = "UTF-8";
436 static bool opt_utf8 = TRUE;
437 static char opt_codeset[20] = "UTF-8";
438 static iconv_t opt_iconv = ICONV_NONE;
439 static char opt_search[SIZEOF_STR] = "";
440 static char opt_cdup[SIZEOF_STR] = "";
441 static char opt_git_dir[SIZEOF_STR] = "";
442 static char opt_is_inside_work_tree = -1; /* set to TRUE or FALSE */
443 static char opt_editor[SIZEOF_STR] = "";
444
445 enum option_type {
446 OPT_NONE,
447 OPT_INT,
448 };
449
450 static bool
451 check_option(char *opt, char short_name, char *name, enum option_type type, ...)
452 {
453 va_list args;
454 char *value = "";
455 int *number;
456
457 if (opt[0] != '-')
458 return FALSE;
459
460 if (opt[1] == '-') {
461 int namelen = strlen(name);
462
463 opt += 2;
464
465 if (strncmp(opt, name, namelen))
466 return FALSE;
467
468 if (opt[namelen] == '=')
469 value = opt + namelen + 1;
470
471 } else {
472 if (!short_name || opt[1] != short_name)
473 return FALSE;
474 value = opt + 2;
475 }
476
477 va_start(args, type);
478 if (type == OPT_INT) {
479 number = va_arg(args, int *);
480 if (isdigit(*value))
481 *number = atoi(value);
482 }
483 va_end(args);
484
485 return TRUE;
486 }
487
488 /* Returns the index of log or diff command or -1 to exit. */
489 static bool
490 parse_options(int argc, char *argv[])
491 {
492 int i;
493
494 for (i = 1; i < argc; i++) {
495 char *opt = argv[i];
496
497 if (!strcmp(opt, "log") ||
498 !strcmp(opt, "diff") ||
499 !strcmp(opt, "show")) {
500 opt_request = opt[0] == 'l'
501 ? REQ_VIEW_LOG : REQ_VIEW_DIFF;
502 break;
503 }
504
505 if (opt[0] && opt[0] != '-')
506 break;
507
508 if (!strcmp(opt, "-l")) {
509 opt_request = REQ_VIEW_LOG;
510 continue;
511 }
512
513 if (!strcmp(opt, "-d")) {
514 opt_request = REQ_VIEW_DIFF;
515 continue;
516 }
517
518 if (!strcmp(opt, "-S")) {
519 opt_request = REQ_VIEW_STATUS;
520 continue;
521 }
522
523 if (check_option(opt, 'n', "line-number", OPT_INT, &opt_num_interval)) {
524 opt_line_number = TRUE;
525 continue;
526 }
527
528 if (check_option(opt, 'b', "tab-size", OPT_INT, &opt_tab_size)) {
529 opt_tab_size = MIN(opt_tab_size, TABSIZE);
530 continue;
531 }
532
533 if (check_option(opt, 'v', "version", OPT_NONE)) {
534 printf("tig version %s\n", TIG_VERSION);
535 return FALSE;
536 }
537
538 if (check_option(opt, 'h', "help", OPT_NONE)) {
539 printf(usage);
540 return FALSE;
541 }
542
543 if (!strcmp(opt, "--")) {
544 i++;
545 break;
546 }
547
548 die("unknown option '%s'\n\n%s", opt, usage);
549 }
550
551 if (!isatty(STDIN_FILENO)) {
552 opt_request = REQ_VIEW_PAGER;
553 opt_pipe = stdin;
554
555 } else if (i < argc) {
556 size_t buf_size;
557
558 if (opt_request == REQ_VIEW_MAIN)
559 /* XXX: This is vulnerable to the user overriding
560 * options required for the main view parser. */
561 string_copy(opt_cmd, "git log --pretty=raw");
562 else
563 string_copy(opt_cmd, "git");
564 buf_size = strlen(opt_cmd);
565
566 while (buf_size < sizeof(opt_cmd) && i < argc) {
567 opt_cmd[buf_size++] = ' ';
568 buf_size = sq_quote(opt_cmd, buf_size, argv[i++]);
569 }
570
571 if (buf_size >= sizeof(opt_cmd))
572 die("command too long");
573
574 opt_cmd[buf_size] = 0;
575 }
576
577 if (*opt_encoding && strcasecmp(opt_encoding, "UTF-8"))
578 opt_utf8 = FALSE;
579
580 return TRUE;
581 }
582
583
584 /*
585 * Line-oriented content detection.
586 */
587
588 #define LINE_INFO \
589 LINE(DIFF_HEADER, "diff --git ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
590 LINE(DIFF_CHUNK, "@@", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
591 LINE(DIFF_ADD, "+", COLOR_GREEN, COLOR_DEFAULT, 0), \
592 LINE(DIFF_DEL, "-", COLOR_RED, COLOR_DEFAULT, 0), \
593 LINE(DIFF_INDEX, "index ", COLOR_BLUE, COLOR_DEFAULT, 0), \
594 LINE(DIFF_OLDMODE, "old file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
595 LINE(DIFF_NEWMODE, "new file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
596 LINE(DIFF_COPY_FROM, "copy from", COLOR_YELLOW, COLOR_DEFAULT, 0), \
597 LINE(DIFF_COPY_TO, "copy to", COLOR_YELLOW, COLOR_DEFAULT, 0), \
598 LINE(DIFF_RENAME_FROM, "rename from", COLOR_YELLOW, COLOR_DEFAULT, 0), \
599 LINE(DIFF_RENAME_TO, "rename to", COLOR_YELLOW, COLOR_DEFAULT, 0), \
600 LINE(DIFF_SIMILARITY, "similarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
601 LINE(DIFF_DISSIMILARITY,"dissimilarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
602 LINE(DIFF_TREE, "diff-tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
603 LINE(PP_AUTHOR, "Author: ", COLOR_CYAN, COLOR_DEFAULT, 0), \
604 LINE(PP_COMMIT, "Commit: ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
605 LINE(PP_MERGE, "Merge: ", COLOR_BLUE, COLOR_DEFAULT, 0), \
606 LINE(PP_DATE, "Date: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
607 LINE(PP_ADATE, "AuthorDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
608 LINE(PP_CDATE, "CommitDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
609 LINE(PP_REFS, "Refs: ", COLOR_RED, COLOR_DEFAULT, 0), \
610 LINE(COMMIT, "commit ", COLOR_GREEN, COLOR_DEFAULT, 0), \
611 LINE(PARENT, "parent ", COLOR_BLUE, COLOR_DEFAULT, 0), \
612 LINE(TREE, "tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
613 LINE(AUTHOR, "author ", COLOR_CYAN, COLOR_DEFAULT, 0), \
614 LINE(COMMITTER, "committer ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
615 LINE(SIGNOFF, " Signed-off-by", COLOR_YELLOW, COLOR_DEFAULT, 0), \
616 LINE(ACKED, " Acked-by", COLOR_YELLOW, COLOR_DEFAULT, 0), \
617 LINE(DEFAULT, "", COLOR_DEFAULT, COLOR_DEFAULT, A_NORMAL), \
618 LINE(CURSOR, "", COLOR_WHITE, COLOR_GREEN, A_BOLD), \
619 LINE(STATUS, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
620 LINE(TITLE_BLUR, "", COLOR_WHITE, COLOR_BLUE, 0), \
621 LINE(TITLE_FOCUS, "", COLOR_WHITE, COLOR_BLUE, A_BOLD), \
622 LINE(MAIN_DATE, "", COLOR_BLUE, COLOR_DEFAULT, 0), \
623 LINE(MAIN_AUTHOR, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
624 LINE(MAIN_COMMIT, "", COLOR_DEFAULT, COLOR_DEFAULT, 0), \
625 LINE(MAIN_DELIM, "", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
626 LINE(MAIN_TAG, "", COLOR_MAGENTA, COLOR_DEFAULT, A_BOLD), \
627 LINE(MAIN_REMOTE, "", COLOR_YELLOW, COLOR_DEFAULT, A_BOLD), \
628 LINE(MAIN_REF, "", COLOR_CYAN, COLOR_DEFAULT, A_BOLD), \
629 LINE(TREE_DIR, "", COLOR_DEFAULT, COLOR_DEFAULT, A_NORMAL), \
630 LINE(TREE_FILE, "", COLOR_DEFAULT, COLOR_DEFAULT, A_NORMAL), \
631 LINE(STAT_SECTION, "", COLOR_CYAN, COLOR_DEFAULT, 0), \
632 LINE(STAT_NONE, "", COLOR_DEFAULT, COLOR_DEFAULT, 0), \
633 LINE(STAT_STAGED, "", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
634 LINE(STAT_UNSTAGED,"", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
635 LINE(STAT_UNTRACKED,"", COLOR_MAGENTA, COLOR_DEFAULT, 0)
636
637 enum line_type {
638 #define LINE(type, line, fg, bg, attr) \
639 LINE_##type
640 LINE_INFO
641 #undef LINE
642 };
643
644 struct line_info {
645 const char *name; /* Option name. */
646 int namelen; /* Size of option name. */
647 const char *line; /* The start of line to match. */
648 int linelen; /* Size of string to match. */
649 int fg, bg, attr; /* Color and text attributes for the lines. */
650 };
651
652 static struct line_info line_info[] = {
653 #define LINE(type, line, fg, bg, attr) \
654 { #type, STRING_SIZE(#type), (line), STRING_SIZE(line), (fg), (bg), (attr) }
655 LINE_INFO
656 #undef LINE
657 };
658
659 static enum line_type
660 get_line_type(char *line)
661 {
662 int linelen = strlen(line);
663 enum line_type type;
664
665 for (type = 0; type < ARRAY_SIZE(line_info); type++)
666 /* Case insensitive search matches Signed-off-by lines better. */
667 if (linelen >= line_info[type].linelen &&
668 !strncasecmp(line_info[type].line, line, line_info[type].linelen))
669 return type;
670
671 return LINE_DEFAULT;
672 }
673
674 static inline int
675 get_line_attr(enum line_type type)
676 {
677 assert(type < ARRAY_SIZE(line_info));
678 return COLOR_PAIR(type) | line_info[type].attr;
679 }
680
681 static struct line_info *
682 get_line_info(char *name, int namelen)
683 {
684 enum line_type type;
685
686 for (type = 0; type < ARRAY_SIZE(line_info); type++)
687 if (namelen == line_info[type].namelen &&
688 !string_enum_compare(line_info[type].name, name, namelen))
689 return &line_info[type];
690
691 return NULL;
692 }
693
694 static void
695 init_colors(void)
696 {
697 int default_bg = COLOR_BLACK;
698 int default_fg = COLOR_WHITE;
699 enum line_type type;
700
701 start_color();
702
703 if (use_default_colors() != ERR) {
704 default_bg = -1;
705 default_fg = -1;
706 }
707
708 for (type = 0; type < ARRAY_SIZE(line_info); type++) {
709 struct line_info *info = &line_info[type];
710 int bg = info->bg == COLOR_DEFAULT ? default_bg : info->bg;
711 int fg = info->fg == COLOR_DEFAULT ? default_fg : info->fg;
712
713 init_pair(type, fg, bg);
714 }
715 }
716
717 struct line {
718 enum line_type type;
719
720 /* State flags */
721 unsigned int selected:1;
722
723 void *data; /* User data */
724 };
725
726
727 /*
728 * Keys
729 */
730
731 struct keybinding {
732 int alias;
733 enum request request;
734 struct keybinding *next;
735 };
736
737 static struct keybinding default_keybindings[] = {
738 /* View switching */
739 { 'm', REQ_VIEW_MAIN },
740 { 'd', REQ_VIEW_DIFF },
741 { 'l', REQ_VIEW_LOG },
742 { 't', REQ_VIEW_TREE },
743 { 'f', REQ_VIEW_BLOB },
744 { 'p', REQ_VIEW_PAGER },
745 { 'h', REQ_VIEW_HELP },
746 { 'S', REQ_VIEW_STATUS },
747 { 'c', REQ_VIEW_STAGE },
748
749 /* View manipulation */
750 { 'q', REQ_VIEW_CLOSE },
751 { KEY_TAB, REQ_VIEW_NEXT },
752 { KEY_RETURN, REQ_ENTER },
753 { KEY_UP, REQ_PREVIOUS },
754 { KEY_DOWN, REQ_NEXT },
755 { 'R', REQ_REFRESH },
756
757 /* Cursor navigation */
758 { 'k', REQ_MOVE_UP },
759 { 'j', REQ_MOVE_DOWN },
760 { KEY_HOME, REQ_MOVE_FIRST_LINE },
761 { KEY_END, REQ_MOVE_LAST_LINE },
762 { KEY_NPAGE, REQ_MOVE_PAGE_DOWN },
763 { ' ', REQ_MOVE_PAGE_DOWN },
764 { KEY_PPAGE, REQ_MOVE_PAGE_UP },
765 { 'b', REQ_MOVE_PAGE_UP },
766 { '-', REQ_MOVE_PAGE_UP },
767
768 /* Scrolling */
769 { KEY_IC, REQ_SCROLL_LINE_UP },
770 { KEY_DC, REQ_SCROLL_LINE_DOWN },
771 { 'w', REQ_SCROLL_PAGE_UP },
772 { 's', REQ_SCROLL_PAGE_DOWN },
773
774 /* Searching */
775 { '/', REQ_SEARCH },
776 { '?', REQ_SEARCH_BACK },
777 { 'n', REQ_FIND_NEXT },
778 { 'N', REQ_FIND_PREV },
779
780 /* Misc */
781 { 'Q', REQ_QUIT },
782 { 'z', REQ_STOP_LOADING },
783 { 'v', REQ_SHOW_VERSION },
784 { 'r', REQ_SCREEN_REDRAW },
785 { '.', REQ_TOGGLE_LINENO },
786 { 'g', REQ_TOGGLE_REV_GRAPH },
787 { ':', REQ_PROMPT },
788 { 'u', REQ_STATUS_UPDATE },
789 { 'M', REQ_STATUS_MERGE },
790 { 'e', REQ_EDIT },
791
792 /* Using the ncurses SIGWINCH handler. */
793 { KEY_RESIZE, REQ_SCREEN_RESIZE },
794 };
795
796 #define KEYMAP_INFO \
797 KEYMAP_(GENERIC), \
798 KEYMAP_(MAIN), \
799 KEYMAP_(DIFF), \
800 KEYMAP_(LOG), \
801 KEYMAP_(TREE), \
802 KEYMAP_(BLOB), \
803 KEYMAP_(PAGER), \
804 KEYMAP_(HELP), \
805 KEYMAP_(STATUS), \
806 KEYMAP_(STAGE)
807
808 enum keymap {
809 #define KEYMAP_(name) KEYMAP_##name
810 KEYMAP_INFO
811 #undef KEYMAP_
812 };
813
814 static struct int_map keymap_table[] = {
815 #define KEYMAP_(name) { #name, STRING_SIZE(#name), KEYMAP_##name }
816 KEYMAP_INFO
817 #undef KEYMAP_
818 };
819
820 #define set_keymap(map, name) \
821 set_from_int_map(keymap_table, ARRAY_SIZE(keymap_table), map, name, strlen(name))
822
823 static struct keybinding *keybindings[ARRAY_SIZE(keymap_table)];
824
825 static void
826 add_keybinding(enum keymap keymap, enum request request, int key)
827 {
828 struct keybinding *keybinding;
829
830 keybinding = calloc(1, sizeof(*keybinding));
831 if (!keybinding)
832 die("Failed to allocate keybinding");
833
834 keybinding->alias = key;
835 keybinding->request = request;
836 keybinding->next = keybindings[keymap];
837 keybindings[keymap] = keybinding;
838 }
839
840 /* Looks for a key binding first in the given map, then in the generic map, and
841 * lastly in the default keybindings. */
842 static enum request
843 get_keybinding(enum keymap keymap, int key)
844 {
845 struct keybinding *kbd;
846 int i;
847
848 for (kbd = keybindings[keymap]; kbd; kbd = kbd->next)
849 if (kbd->alias == key)
850 return kbd->request;
851
852 for (kbd = keybindings[KEYMAP_GENERIC]; kbd; kbd = kbd->next)
853 if (kbd->alias == key)
854 return kbd->request;
855
856 for (i = 0; i < ARRAY_SIZE(default_keybindings); i++)
857 if (default_keybindings[i].alias == key)
858 return default_keybindings[i].request;
859
860 return (enum request) key;
861 }
862
863
864 struct key {
865 char *name;
866 int value;
867 };
868
869 static struct key key_table[] = {
870 { "Enter", KEY_RETURN },
871 { "Space", ' ' },
872 { "Backspace", KEY_BACKSPACE },
873 { "Tab", KEY_TAB },
874 { "Escape", KEY_ESC },
875 { "Left", KEY_LEFT },
876 { "Right", KEY_RIGHT },
877 { "Up", KEY_UP },
878 { "Down", KEY_DOWN },
879 { "Insert", KEY_IC },
880 { "Delete", KEY_DC },
881 { "Hash", '#' },
882 { "Home", KEY_HOME },
883 { "End", KEY_END },
884 { "PageUp", KEY_PPAGE },
885 { "PageDown", KEY_NPAGE },
886 { "F1", KEY_F(1) },
887 { "F2", KEY_F(2) },
888 { "F3", KEY_F(3) },
889 { "F4", KEY_F(4) },
890 { "F5", KEY_F(5) },
891 { "F6", KEY_F(6) },
892 { "F7", KEY_F(7) },
893 { "F8", KEY_F(8) },
894 { "F9", KEY_F(9) },
895 { "F10", KEY_F(10) },
896 { "F11", KEY_F(11) },
897 { "F12", KEY_F(12) },
898 };
899
900 static int
901 get_key_value(const char *name)
902 {
903 int i;
904
905 for (i = 0; i < ARRAY_SIZE(key_table); i++)
906 if (!strcasecmp(key_table[i].name, name))
907 return key_table[i].value;
908
909 if (strlen(name) == 1 && isprint(*name))
910 return (int) *name;
911
912 return ERR;
913 }
914
915 static char *
916 get_key_name(int key_value)
917 {
918 static char key_char[] = "'X'";
919 char *seq = NULL;
920 int key;
921
922 for (key = 0; key < ARRAY_SIZE(key_table); key++)
923 if (key_table[key].value == key_value)
924 seq = key_table[key].name;
925
926 if (seq == NULL &&
927 key_value < 127 &&
928 isprint(key_value)) {
929 key_char[1] = (char) key_value;
930 seq = key_char;
931 }
932
933 return seq ? seq : "'?'";
934 }
935
936 static char *
937 get_key(enum request request)
938 {
939 static char buf[BUFSIZ];
940 static char key_char[] = "'X'";
941 size_t pos = 0;
942 char *sep = "";
943 int i;
944
945 buf[pos] = 0;
946
947 for (i = 0; i < ARRAY_SIZE(default_keybindings); i++) {
948 struct keybinding *keybinding = &default_keybindings[i];
949 char *seq = NULL;
950 int key;
951
952 if (keybinding->request != request)
953 continue;
954
955 for (key = 0; key < ARRAY_SIZE(key_table); key++)
956 if (key_table[key].value == keybinding->alias)
957 seq = key_table[key].name;
958
959 if (seq == NULL &&
960 keybinding->alias < 127 &&
961 isprint(keybinding->alias)) {
962 key_char[1] = (char) keybinding->alias;
963 seq = key_char;
964 }
965
966 if (!seq)
967 seq = "'?'";
968
969 if (!string_format_from(buf, &pos, "%s%s", sep, seq))
970 return "Too many keybindings!";
971 sep = ", ";
972 }
973
974 return buf;
975 }
976
977 struct run_request {
978 enum keymap keymap;
979 int key;
980 char cmd[SIZEOF_STR];
981 };
982
983 static struct run_request *run_request;
984 static size_t run_requests;
985
986 static enum request
987 add_run_request(enum keymap keymap, int key, int argc, char **argv)
988 {
989 struct run_request *tmp;
990 struct run_request req = { keymap, key };
991 size_t bufpos;
992
993 for (bufpos = 0; argc > 0; argc--, argv++)
994 if (!string_format_from(req.cmd, &bufpos, "%s ", *argv))
995 return REQ_NONE;
996
997 req.cmd[bufpos - 1] = 0;
998
999 tmp = realloc(run_request, (run_requests + 1) * sizeof(*run_request));
1000 if (!tmp)
1001 return REQ_NONE;
1002
1003 run_request = tmp;
1004 run_request[run_requests++] = req;
1005
1006 return REQ_NONE + run_requests;
1007 }
1008
1009 static struct run_request *
1010 get_run_request(enum request request)
1011 {
1012 if (request <= REQ_NONE)
1013 return NULL;
1014 return &run_request[request - REQ_NONE - 1];
1015 }
1016
1017 static void
1018 add_builtin_run_requests(void)
1019 {
1020 struct {
1021 enum keymap keymap;
1022 int key;
1023 char *argv[1];
1024 } reqs[] = {
1025 { KEYMAP_MAIN, 'C', { "git cherry-pick %(commit)" } },
1026 { KEYMAP_GENERIC, 'G', { "git gc" } },
1027 };
1028 int i;
1029
1030 for (i = 0; i < ARRAY_SIZE(reqs); i++) {
1031 enum request req;
1032
1033 req = add_run_request(reqs[i].keymap, reqs[i].key, 1, reqs[i].argv);
1034 if (req != REQ_NONE)
1035 add_keybinding(reqs[i].keymap, req, reqs[i].key);
1036 }
1037 }
1038
1039 /*
1040 * User config file handling.
1041 */
1042
1043 static struct int_map color_map[] = {
1044 #define COLOR_MAP(name) { #name, STRING_SIZE(#name), COLOR_##name }
1045 COLOR_MAP(DEFAULT),
1046 COLOR_MAP(BLACK),
1047 COLOR_MAP(BLUE),
1048 COLOR_MAP(CYAN),
1049 COLOR_MAP(GREEN),
1050 COLOR_MAP(MAGENTA),
1051 COLOR_MAP(RED),
1052 COLOR_MAP(WHITE),
1053 COLOR_MAP(YELLOW),
1054 };
1055
1056 #define set_color(color, name) \
1057 set_from_int_map(color_map, ARRAY_SIZE(color_map), color, name, strlen(name))
1058
1059 static struct int_map attr_map[] = {
1060 #define ATTR_MAP(name) { #name, STRING_SIZE(#name), A_##name }
1061 ATTR_MAP(NORMAL),
1062 ATTR_MAP(BLINK),
1063 ATTR_MAP(BOLD),
1064 ATTR_MAP(DIM),
1065 ATTR_MAP(REVERSE),
1066 ATTR_MAP(STANDOUT),
1067 ATTR_MAP(UNDERLINE),
1068 };
1069
1070 #define set_attribute(attr, name) \
1071 set_from_int_map(attr_map, ARRAY_SIZE(attr_map), attr, name, strlen(name))
1072
1073 static int config_lineno;
1074 static bool config_errors;
1075 static char *config_msg;
1076
1077 /* Wants: object fgcolor bgcolor [attr] */
1078 static int
1079 option_color_command(int argc, char *argv[])
1080 {
1081 struct line_info *info;
1082
1083 if (argc != 3 && argc != 4) {
1084 config_msg = "Wrong number of arguments given to color command";
1085 return ERR;
1086 }
1087
1088 info = get_line_info(argv[0], strlen(argv[0]));
1089 if (!info) {
1090 config_msg = "Unknown color name";
1091 return ERR;
1092 }
1093
1094 if (set_color(&info->fg, argv[1]) == ERR ||
1095 set_color(&info->bg, argv[2]) == ERR) {
1096 config_msg = "Unknown color";
1097 return ERR;
1098 }
1099
1100 if (argc == 4 && set_attribute(&info->attr, argv[3]) == ERR) {
1101 config_msg = "Unknown attribute";
1102 return ERR;
1103 }
1104
1105 return OK;
1106 }
1107
1108 /* Wants: name = value */
1109 static int
1110 option_set_command(int argc, char *argv[])
1111 {
1112 if (argc != 3) {
1113 config_msg = "Wrong number of arguments given to set command";
1114 return ERR;
1115 }
1116
1117 if (strcmp(argv[1], "=")) {
1118 config_msg = "No value assigned";
1119 return ERR;
1120 }
1121
1122 if (!strcmp(argv[0], "show-rev-graph")) {
1123 opt_rev_graph = (!strcmp(argv[2], "1") ||
1124 !strcmp(argv[2], "true") ||
1125 !strcmp(argv[2], "yes"));
1126 return OK;
1127 }
1128
1129 if (!strcmp(argv[0], "line-number-interval")) {
1130 opt_num_interval = atoi(argv[2]);
1131 return OK;
1132 }
1133
1134 if (!strcmp(argv[0], "tab-size")) {
1135 opt_tab_size = atoi(argv[2]);
1136 return OK;
1137 }
1138
1139 if (!strcmp(argv[0], "commit-encoding")) {
1140 char *arg = argv[2];
1141 int delimiter = *arg;
1142 int i;
1143
1144 switch (delimiter) {
1145 case '"':
1146 case '\'':
1147 for (arg++, i = 0; arg[i]; i++)
1148 if (arg[i] == delimiter) {
1149 arg[i] = 0;
1150 break;
1151 }
1152 default:
1153 string_ncopy(opt_encoding, arg, strlen(arg));
1154 return OK;
1155 }
1156 }
1157
1158 config_msg = "Unknown variable name";
1159 return ERR;
1160 }
1161
1162 /* Wants: mode request key */
1163 static int
1164 option_bind_command(int argc, char *argv[])
1165 {
1166 enum request request;
1167 int keymap;
1168 int key;
1169
1170 if (argc < 3) {
1171 config_msg = "Wrong number of arguments given to bind command";
1172 return ERR;
1173 }
1174
1175 if (set_keymap(&keymap, argv[0]) == ERR) {
1176 config_msg = "Unknown key map";
1177 return ERR;
1178 }
1179
1180 key = get_key_value(argv[1]);
1181 if (key == ERR) {
1182 config_msg = "Unknown key";
1183 return ERR;
1184 }
1185
1186 request = get_request(argv[2]);
1187 if (request = REQ_NONE) {
1188 const char *obsolete[] = { "cherry-pick" };
1189 size_t namelen = strlen(argv[2]);
1190 int i;
1191
1192 for (i = 0; i < ARRAY_SIZE(obsolete); i++) {
1193 if (namelen == strlen(obsolete[i]) &&
1194 !string_enum_compare(obsolete[i], argv[2], namelen)) {
1195 config_msg = "Obsolete request name";
1196 return ERR;
1197 }
1198 }
1199 }
1200 if (request == REQ_NONE && *argv[2]++ == '!')
1201 request = add_run_request(keymap, key, argc - 2, argv + 2);
1202 if (request == REQ_NONE) {
1203 config_msg = "Unknown request name";
1204 return ERR;
1205 }
1206
1207 add_keybinding(keymap, request, key);
1208
1209 return OK;
1210 }
1211
1212 static int
1213 set_option(char *opt, char *value)
1214 {
1215 char *argv[16];
1216 int valuelen;
1217 int argc = 0;
1218
1219 /* Tokenize */
1220 while (argc < ARRAY_SIZE(argv) && (valuelen = strcspn(value, " \t"))) {
1221 argv[argc++] = value;
1222
1223 value += valuelen;
1224 if (!*value)
1225 break;
1226
1227 *value++ = 0;
1228 while (isspace(*value))
1229 value++;
1230 }
1231
1232 if (!strcmp(opt, "color"))
1233 return option_color_command(argc, argv);
1234
1235 if (!strcmp(opt, "set"))
1236 return option_set_command(argc, argv);
1237
1238 if (!strcmp(opt, "bind"))
1239 return option_bind_command(argc, argv);
1240
1241 config_msg = "Unknown option command";
1242 return ERR;
1243 }
1244
1245 static int
1246 read_option(char *opt, size_t optlen, char *value, size_t valuelen)
1247 {
1248 int status = OK;
1249
1250 config_lineno++;
1251 config_msg = "Internal error";
1252
1253 /* Check for comment markers, since read_properties() will
1254 * only ensure opt and value are split at first " \t". */
1255 optlen = strcspn(opt, "#");
1256 if (optlen == 0)
1257 return OK;
1258
1259 if (opt[optlen] != 0) {
1260 config_msg = "No option value";
1261 status = ERR;
1262
1263 } else {
1264 /* Look for comment endings in the value. */
1265 size_t len = strcspn(value, "#");
1266
1267 if (len < valuelen) {
1268 valuelen = len;
1269 value[valuelen] = 0;
1270 }
1271
1272 status = set_option(opt, value);
1273 }
1274
1275 if (status == ERR) {
1276 fprintf(stderr, "Error on line %d, near '%.*s': %s\n",
1277 config_lineno, (int) optlen, opt, config_msg);
1278 config_errors = TRUE;
1279 }
1280
1281 /* Always keep going if errors are encountered. */
1282 return OK;
1283 }
1284
1285 static int
1286 load_options(void)
1287 {
1288 char *home = getenv("HOME");
1289 char buf[SIZEOF_STR];
1290 FILE *file;
1291
1292 config_lineno = 0;
1293 config_errors = FALSE;
1294
1295 add_builtin_run_requests();
1296
1297 if (!home || !string_format(buf, "%s/.tigrc", home))
1298 return ERR;
1299
1300 /* It's ok that the file doesn't exist. */
1301 file = fopen(buf, "r");
1302 if (!file)
1303 return OK;
1304
1305 if (read_properties(file, " \t", read_option) == ERR ||
1306 config_errors == TRUE)
1307 fprintf(stderr, "Errors while loading %s.\n", buf);
1308
1309 return OK;
1310 }
1311
1312
1313 /*
1314 * The viewer
1315 */
1316
1317 struct view;
1318 struct view_ops;
1319
1320 /* The display array of active views and the index of the current view. */
1321 static struct view *display[2];
1322 static unsigned int current_view;
1323
1324 /* Reading from the prompt? */
1325 static bool input_mode = FALSE;
1326
1327 #define foreach_displayed_view(view, i) \
1328 for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
1329
1330 #define displayed_views() (display[1] != NULL ? 2 : 1)
1331
1332 /* Current head and commit ID */
1333 static char ref_blob[SIZEOF_REF] = "";
1334 static char ref_commit[SIZEOF_REF] = "HEAD";
1335 static char ref_head[SIZEOF_REF] = "HEAD";
1336
1337 struct view {
1338 const char *name; /* View name */
1339 const char *cmd_fmt; /* Default command line format */
1340 const char *cmd_env; /* Command line set via environment */
1341 const char *id; /* Points to either of ref_{head,commit,blob} */
1342
1343 struct view_ops *ops; /* View operations */
1344
1345 enum keymap keymap; /* What keymap does this view have */
1346
1347 char cmd[SIZEOF_STR]; /* Command buffer */
1348 char ref[SIZEOF_REF]; /* Hovered commit reference */
1349 char vid[SIZEOF_REF]; /* View ID. Set to id member when updating. */
1350
1351 int height, width; /* The width and height of the main window */
1352 WINDOW *win; /* The main window */
1353 WINDOW *title; /* The title window living below the main window */
1354
1355 /* Navigation */
1356 unsigned long offset; /* Offset of the window top */
1357 unsigned long lineno; /* Current line number */
1358
1359 /* Searching */
1360 char grep[SIZEOF_STR]; /* Search string */
1361 regex_t *regex; /* Pre-compiled regex */
1362
1363 /* If non-NULL, points to the view that opened this view. If this view
1364 * is closed tig will switch back to the parent view. */
1365 struct view *parent;
1366
1367 /* Buffering */
1368 unsigned long lines; /* Total number of lines */
1369 struct line *line; /* Line index */
1370 unsigned long line_size;/* Total number of allocated lines */
1371 unsigned int digits; /* Number of digits in the lines member. */
1372
1373 /* Loading */
1374 FILE *pipe;
1375 time_t start_time;
1376 };
1377
1378 struct view_ops {
1379 /* What type of content being displayed. Used in the title bar. */
1380 const char *type;
1381 /* Open and reads in all view content. */
1382 bool (*open)(struct view *view);
1383 /* Read one line; updates view->line. */
1384 bool (*read)(struct view *view, char *data);
1385 /* Draw one line; @lineno must be < view->height. */
1386 bool (*draw)(struct view *view, struct line *line, unsigned int lineno, bool selected);
1387 /* Depending on view handle a special requests. */
1388 enum request (*request)(struct view *view, enum request request, struct line *line);
1389 /* Search for regex in a line. */
1390 bool (*grep)(struct view *view, struct line *line);
1391 /* Select line */
1392 void (*select)(struct view *view, struct line *line);
1393 };
1394
1395 static struct view_ops pager_ops;
1396 static struct view_ops main_ops;
1397 static struct view_ops tree_ops;
1398 static struct view_ops blob_ops;
1399 static struct view_ops help_ops;
1400 static struct view_ops status_ops;
1401 static struct view_ops stage_ops;
1402
1403 #define VIEW_STR(name, cmd, env, ref, ops, map) \
1404 { name, cmd, #env, ref, ops, map}
1405
1406 #define VIEW_(id, name, ops, ref) \
1407 VIEW_STR(name, TIG_##id##_CMD, TIG_##id##_CMD, ref, ops, KEYMAP_##id)
1408
1409
1410 static struct view views[] = {
1411 VIEW_(MAIN, "main", &main_ops, ref_head),
1412 VIEW_(DIFF, "diff", &pager_ops, ref_commit),
1413 VIEW_(LOG, "log", &pager_ops, ref_head),
1414 VIEW_(TREE, "tree", &tree_ops, ref_commit),
1415 VIEW_(BLOB, "blob", &blob_ops, ref_blob),
1416 VIEW_(HELP, "help", &help_ops, ""),
1417 VIEW_(PAGER, "pager", &pager_ops, "stdin"),
1418 VIEW_(STATUS, "status", &status_ops, ""),
1419 VIEW_(STAGE, "stage", &stage_ops, ""),
1420 };
1421
1422 #define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
1423
1424 #define foreach_view(view, i) \
1425 for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
1426
1427 #define view_is_displayed(view) \
1428 (view == display[0] || view == display[1])
1429
1430 static bool
1431 draw_view_line(struct view *view, unsigned int lineno)
1432 {
1433 struct line *line;
1434 bool selected = (view->offset + lineno == view->lineno);
1435 bool draw_ok;
1436
1437 assert(view_is_displayed(view));
1438
1439 if (view->offset + lineno >= view->lines)
1440 return FALSE;
1441
1442 line = &view->line[view->offset + lineno];
1443
1444 if (selected) {
1445 line->selected = TRUE;
1446 view->ops->select(view, line);
1447 } else if (line->selected) {
1448 line->selected = FALSE;
1449 wmove(view->win, lineno, 0);
1450 wclrtoeol(view->win);
1451 }
1452
1453 scrollok(view->win, FALSE);
1454 draw_ok = view->ops->draw(view, line, lineno, selected);
1455 scrollok(view->win, TRUE);
1456
1457 return draw_ok;
1458 }
1459
1460 static void
1461 redraw_view_from(struct view *view, int lineno)
1462 {
1463 assert(0 <= lineno && lineno < view->height);
1464
1465 for (; lineno < view->height; lineno++) {
1466 if (!draw_view_line(view, lineno))
1467 break;
1468 }
1469
1470 redrawwin(view->win);
1471 if (input_mode)
1472 wnoutrefresh(view->win);
1473 else
1474 wrefresh(view->win);
1475 }
1476
1477 static void
1478 redraw_view(struct view *view)
1479 {
1480 wclear(view->win);
1481 redraw_view_from(view, 0);
1482 }
1483
1484
1485 static void
1486 update_view_title(struct view *view)
1487 {
1488 char buf[SIZEOF_STR];
1489 char state[SIZEOF_STR];
1490 size_t bufpos = 0, statelen = 0;
1491
1492 assert(view_is_displayed(view));
1493
1494 if (view != VIEW(REQ_VIEW_STATUS) && (view->lines || view->pipe)) {
1495 unsigned int view_lines = view->offset + view->height;
1496 unsigned int lines = view->lines
1497 ? MIN(view_lines, view->lines) * 100 / view->lines
1498 : 0;
1499
1500 string_format_from(state, &statelen, "- %s %d of %d (%d%%)",
1501 view->ops->type,
1502 view->lineno + 1,
1503 view->lines,
1504 lines);
1505
1506 if (view->pipe) {
1507 time_t secs = time(NULL) - view->start_time;
1508
1509 /* Three git seconds are a long time ... */
1510 if (secs > 2)
1511 string_format_from(state, &statelen, " %lds", secs);
1512 }
1513 }
1514
1515 string_format_from(buf, &bufpos, "[%s]", view->name);
1516 if (*view->ref && bufpos < view->width) {
1517 size_t refsize = strlen(view->ref);
1518 size_t minsize = bufpos + 1 + /* abbrev= */ 7 + 1 + statelen;
1519
1520 if (minsize < view->width)
1521 refsize = view->width - minsize + 7;
1522 string_format_from(buf, &bufpos, " %.*s", (int) refsize, view->ref);
1523 }
1524
1525 if (statelen && bufpos < view->width) {
1526 string_format_from(buf, &bufpos, " %s", state);
1527 }
1528
1529 if (view == display[current_view])
1530 wbkgdset(view->title, get_line_attr(LINE_TITLE_FOCUS));
1531 else
1532 wbkgdset(view->title, get_line_attr(LINE_TITLE_BLUR));
1533
1534 mvwaddnstr(view->title, 0, 0, buf, bufpos);
1535 wclrtoeol(view->title);
1536 wmove(view->title, 0, view->width - 1);
1537
1538 if (input_mode)
1539 wnoutrefresh(view->title);
1540 else
1541 wrefresh(view->title);
1542 }
1543
1544 static void
1545 resize_display(void)
1546 {
1547 int offset, i;
1548 struct view *base = display[0];
1549 struct view *view = display[1] ? display[1] : display[0];
1550
1551 /* Setup window dimensions */
1552
1553 getmaxyx(stdscr, base->height, base->width);
1554
1555 /* Make room for the status window. */
1556 base->height -= 1;
1557
1558 if (view != base) {
1559 /* Horizontal split. */
1560 view->width = base->width;
1561 view->height = SCALE_SPLIT_VIEW(base->height);
1562 base->height -= view->height;
1563
1564 /* Make room for the title bar. */
1565 view->height -= 1;
1566 }
1567
1568 /* Make room for the title bar. */
1569 base->height -= 1;
1570
1571 offset = 0;
1572
1573 foreach_displayed_view (view, i) {
1574 if (!view->win) {
1575 view->win = newwin(view->height, 0, offset, 0);
1576 if (!view->win)
1577 die("Failed to create %s view", view->name);
1578
1579 scrollok(view->win, TRUE);
1580
1581 view->title = newwin(1, 0, offset + view->height, 0);
1582 if (!view->title)
1583 die("Failed to create title window");
1584
1585 } else {
1586 wresize(view->win, view->height, view->width);
1587 mvwin(view->win, offset, 0);
1588 mvwin(view->title, offset + view->height, 0);
1589 }
1590
1591 offset += view->height + 1;
1592 }
1593 }
1594
1595 static void
1596 redraw_display(void)
1597 {
1598 struct view *view;
1599 int i;
1600
1601 foreach_displayed_view (view, i) {
1602 redraw_view(view);
1603 update_view_title(view);
1604 }
1605 }
1606
1607 static void
1608 update_display_cursor(struct view *view)
1609 {
1610 /* Move the cursor to the right-most column of the cursor line.
1611 *
1612 * XXX: This could turn out to be a bit expensive, but it ensures that
1613 * the cursor does not jump around. */
1614 if (view->lines) {
1615 wmove(view->win, view->lineno - view->offset, view->width - 1);
1616 wrefresh(view->win);
1617 }
1618 }
1619
1620 /*
1621 * Navigation
1622 */
1623
1624 /* Scrolling backend */
1625 static void
1626 do_scroll_view(struct view *view, int lines)
1627 {
1628 bool redraw_current_line = FALSE;
1629
1630 /* The rendering expects the new offset. */
1631 view->offset += lines;
1632
1633 assert(0 <= view->offset && view->offset < view->lines);
1634 assert(lines);
1635
1636 /* Move current line into the view. */
1637 if (view->lineno < view->offset) {
1638 view->lineno = view->offset;
1639 redraw_current_line = TRUE;
1640 } else if (view->lineno >= view->offset + view->height) {
1641 view->lineno = view->offset + view->height - 1;
1642 redraw_current_line = TRUE;
1643 }
1644
1645 assert(view->offset <= view->lineno && view->lineno < view->lines);
1646
1647 /* Redraw the whole screen if scrolling is pointless. */
1648 if (view->height < ABS(lines)) {
1649 redraw_view(view);
1650
1651 } else {
1652 int line = lines > 0 ? view->height - lines : 0;
1653 int end = line + ABS(lines);
1654
1655 wscrl(view->win, lines);
1656
1657 for (; line < end; line++) {
1658 if (!draw_view_line(view, line))
1659 break;
1660 }
1661
1662 if (redraw_current_line)
1663 draw_view_line(view, view->lineno - view->offset);
1664 }
1665
1666 redrawwin(view->win);
1667 wrefresh(view->win);
1668 report("");
1669 }
1670
1671 /* Scroll frontend */
1672 static void
1673 scroll_view(struct view *view, enum request request)
1674 {
1675 int lines = 1;
1676
1677 assert(view_is_displayed(view));
1678
1679 switch (request) {
1680 case REQ_SCROLL_PAGE_DOWN:
1681 lines = view->height;
1682 case REQ_SCROLL_LINE_DOWN:
1683 if (view->offset + lines > view->lines)
1684 lines = view->lines - view->offset;
1685
1686 if (lines == 0 || view->offset + view->height >= view->lines) {
1687 report("Cannot scroll beyond the last line");
1688 return;
1689 }
1690 break;
1691
1692 case REQ_SCROLL_PAGE_UP:
1693 lines = view->height;
1694 case REQ_SCROLL_LINE_UP:
1695 if (lines > view->offset)
1696 lines = view->offset;
1697
1698 if (lines == 0) {
1699 report("Cannot scroll beyond the first line");
1700 return;
1701 }
1702
1703 lines = -lines;
1704 break;
1705
1706 default:
1707 die("request %d not handled in switch", request);
1708 }
1709
1710 do_scroll_view(view, lines);
1711 }
1712
1713 /* Cursor moving */
1714 static void
1715 move_view(struct view *view, enum request request)
1716 {
1717 int scroll_steps = 0;
1718 int steps;
1719
1720 switch (request) {
1721 case REQ_MOVE_FIRST_LINE:
1722 steps = -view->lineno;
1723 break;
1724
1725 case REQ_MOVE_LAST_LINE:
1726 steps = view->lines - view->lineno - 1;
1727 break;
1728
1729 case REQ_MOVE_PAGE_UP:
1730 steps = view->height > view->lineno
1731 ? -view->lineno : -view->height;
1732 break;
1733
1734 case REQ_MOVE_PAGE_DOWN:
1735 steps = view->lineno + view->height >= view->lines
1736 ? view->lines - view->lineno - 1 : view->height;
1737 break;
1738
1739 case REQ_MOVE_UP:
1740 steps = -1;
1741 break;
1742
1743 case REQ_MOVE_DOWN:
1744 steps = 1;
1745 break;
1746
1747 default:
1748 die("request %d not handled in switch", request);
1749 }
1750
1751 if (steps <= 0 && view->lineno == 0) {
1752 report("Cannot move beyond the first line");
1753 return;
1754
1755 } else if (steps >= 0 && view->lineno + 1 >= view->lines) {
1756 report("Cannot move beyond the last line");
1757 return;
1758 }
1759
1760 /* Move the current line */
1761 view->lineno += steps;
1762 assert(0 <= view->lineno && view->lineno < view->lines);
1763
1764 /* Check whether the view needs to be scrolled */
1765 if (view->lineno < view->offset ||
1766 view->lineno >= view->offset + view->height) {
1767 scroll_steps = steps;
1768 if (steps < 0 && -steps > view->offset) {
1769 scroll_steps = -view->offset;
1770
1771 } else if (steps > 0) {
1772 if (view->lineno == view->lines - 1 &&
1773 view->lines > view->height) {
1774 scroll_steps = view->lines - view->offset - 1;
1775 if (scroll_steps >= view->height)
1776 scroll_steps -= view->height - 1;
1777 }
1778 }
1779 }
1780
1781 if (!view_is_displayed(view)) {
1782 view->offset += scroll_steps;
1783 assert(0 <= view->offset && view->offset < view->lines);
1784 view->ops->select(view, &view->line[view->lineno]);
1785 return;
1786 }
1787
1788 /* Repaint the old "current" line if we be scrolling */
1789 if (ABS(steps) < view->height)
1790 draw_view_line(view, view->lineno - steps - view->offset);
1791
1792 if (scroll_steps) {
1793 do_scroll_view(view, scroll_steps);
1794 return;
1795 }
1796
1797 /* Draw the current line */
1798 draw_view_line(view, view->lineno - view->offset);
1799
1800 redrawwin(view->win);
1801 wrefresh(view->win);
1802 report("");
1803 }
1804
1805
1806 /*
1807 * Searching
1808 */
1809
1810 static void search_view(struct view *view, enum request request);
1811
1812 static bool
1813 find_next_line(struct view *view, unsigned long lineno, struct line *line)
1814 {
1815 assert(view_is_displayed(view));
1816
1817 if (!view->ops->grep(view, line))
1818 return FALSE;
1819
1820 if (lineno - view->offset >= view->height) {
1821 view->offset = lineno;
1822 view->lineno = lineno;
1823 redraw_view(view);
1824
1825 } else {
1826 unsigned long old_lineno = view->lineno - view->offset;
1827
1828 view->lineno = lineno;
1829 draw_view_line(view, old_lineno);
1830
1831 draw_view_line(view, view->lineno - view->offset);
1832 redrawwin(view->win);
1833 wrefresh(view->win);
1834 }
1835
1836 report("Line %ld matches '%s'", lineno + 1, view->grep);
1837 return TRUE;
1838 }
1839
1840 static void
1841 find_next(struct view *view, enum request request)
1842 {
1843 unsigned long lineno = view->lineno;
1844 int direction;
1845
1846 if (!*view->grep) {
1847 if (!*opt_search)
1848 report("No previous search");
1849 else
1850 search_view(view, request);
1851 return;
1852 }
1853
1854 switch (request) {
1855 case REQ_SEARCH:
1856 case REQ_FIND_NEXT:
1857 direction = 1;
1858 break;
1859
1860 case REQ_SEARCH_BACK:
1861 case REQ_FIND_PREV:
1862 direction = -1;
1863 break;
1864
1865 default:
1866 return;
1867 }
1868
1869 if (request == REQ_FIND_NEXT || request == REQ_FIND_PREV)
1870 lineno += direction;
1871
1872 /* Note, lineno is unsigned long so will wrap around in which case it
1873 * will become bigger than view->lines. */
1874 for (; lineno < view->lines; lineno += direction) {
1875 struct line *line = &view->line[lineno];
1876
1877 if (find_next_line(view, lineno, line))
1878 return;
1879 }
1880
1881 report("No match found for '%s'", view->grep);
1882 }
1883
1884 static void
1885 search_view(struct view *view, enum request request)
1886 {
1887 int regex_err;
1888
1889 if (view->regex) {
1890 regfree(view->regex);
1891 *view->grep = 0;
1892 } else {
1893 view->regex = calloc(1, sizeof(*view->regex));
1894 if (!view->regex)
1895 return;
1896 }
1897
1898 regex_err = regcomp(view->regex, opt_search, REG_EXTENDED);
1899 if (regex_err != 0) {
1900 char buf[SIZEOF_STR] = "unknown error";
1901
1902 regerror(regex_err, view->regex, buf, sizeof(buf));
1903 report("Search failed: %s", buf);
1904 return;
1905 }
1906
1907 string_copy(view->grep, opt_search);
1908
1909 find_next(view, request);
1910 }
1911
1912 /*
1913 * Incremental updating
1914 */
1915
1916 static void
1917 end_update(struct view *view)
1918 {
1919 if (!view->pipe)
1920 return;
1921 set_nonblocking_input(FALSE);
1922 if (view->pipe == stdin)
1923 fclose(view->pipe);
1924 else
1925 pclose(view->pipe);
1926 view->pipe = NULL;
1927 }
1928
1929 static bool
1930 begin_update(struct view *view)
1931 {
1932 if (view->pipe)
1933 end_update(view);
1934
1935 if (opt_cmd[0]) {
1936 string_copy(view->cmd, opt_cmd);
1937 opt_cmd[0] = 0;
1938 /* When running random commands, initially show the
1939 * command in the title. However, it maybe later be
1940 * overwritten if a commit line is selected. */
1941 if (view == VIEW(REQ_VIEW_PAGER))
1942 string_copy(view->ref, view->cmd);
1943 else
1944 view->ref[0] = 0;
1945
1946 } else if (view == VIEW(REQ_VIEW_TREE)) {
1947 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
1948 char path[SIZEOF_STR];
1949
1950 if (strcmp(view->vid, view->id))
1951 opt_path[0] = path[0] = 0;
1952 else if (sq_quote(path, 0, opt_path) >= sizeof(path))
1953 return FALSE;
1954
1955 if (!string_format(view->cmd, format, view->id, path))
1956 return FALSE;
1957
1958 } else {
1959 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
1960 const char *id = view->id;
1961
1962 if (!string_format(view->cmd, format, id, id, id, id, id))
1963 return FALSE;
1964
1965 /* Put the current ref_* value to the view title ref
1966 * member. This is needed by the blob view. Most other
1967 * views sets it automatically after loading because the
1968 * first line is a commit line. */
1969 string_copy_rev(view->ref, view->id);
1970 }
1971
1972 /* Special case for the pager view. */
1973 if (opt_pipe) {
1974 view->pipe = opt_pipe;
1975 opt_pipe = NULL;
1976 } else {
1977 view->pipe = popen(view->cmd, "r");
1978 }
1979
1980 if (!view->pipe)
1981 return FALSE;
1982
1983 set_nonblocking_input(TRUE);
1984
1985 view->offset = 0;
1986 view->lines = 0;
1987 view->lineno = 0;
1988 string_copy_rev(view->vid, view->id);
1989
1990 if (view->line) {
1991 int i;
1992
1993 for (i = 0; i < view->lines; i++)
1994 if (view->line[i].data)
1995 free(view->line[i].data);
1996
1997 free(view->line);
1998 view->line = NULL;
1999 }
2000
2001 view->start_time = time(NULL);
2002
2003 return TRUE;
2004 }
2005
2006 static struct line *
2007 realloc_lines(struct view *view, size_t line_size)
2008 {
2009 struct line *tmp = realloc(view->line, sizeof(*view->line) * line_size);
2010
2011 if (!tmp)
2012 return NULL;
2013
2014 view->line = tmp;
2015 view->line_size = line_size;
2016 return view->line;
2017 }
2018
2019 static bool
2020 update_view(struct view *view)
2021 {
2022 char in_buffer[BUFSIZ];
2023 char out_buffer[BUFSIZ * 2];
2024 char *line;
2025 /* The number of lines to read. If too low it will cause too much
2026 * redrawing (and possible flickering), if too high responsiveness
2027 * will suffer. */
2028 unsigned long lines = view->height;
2029 int redraw_from = -1;
2030
2031 if (!view->pipe)
2032 return TRUE;
2033
2034 /* Only redraw if lines are visible. */
2035 if (view->offset + view->height >= view->lines)
2036 redraw_from = view->lines - view->offset;
2037
2038 /* FIXME: This is probably not perfect for backgrounded views. */
2039 if (!realloc_lines(view, view->lines + lines))
2040 goto alloc_error;
2041
2042 while ((line = fgets(in_buffer, sizeof(in_buffer), view->pipe))) {
2043 size_t linelen = strlen(line);
2044
2045 if (linelen)
2046 line[linelen - 1] = 0;
2047
2048 if (opt_iconv != ICONV_NONE) {
2049 ICONV_CONST char *inbuf = line;
2050 size_t inlen = linelen;
2051
2052 char *outbuf = out_buffer;
2053 size_t outlen = sizeof(out_buffer);
2054
2055 size_t ret;
2056
2057 ret = iconv(opt_iconv, &inbuf, &inlen, &outbuf, &outlen);
2058 if (ret != (size_t) -1) {
2059 line = out_buffer;
2060 linelen = strlen(out_buffer);
2061 }
2062 }
2063
2064 if (!view->ops->read(view, line))
2065 goto alloc_error;
2066
2067 if (lines-- == 1)
2068 break;
2069 }
2070
2071 {
2072 int digits;
2073
2074 lines = view->lines;
2075 for (digits = 0; lines; digits++)
2076 lines /= 10;
2077
2078 /* Keep the displayed view in sync with line number scaling. */
2079 if (digits != view->digits) {
2080 view->digits = digits;
2081 redraw_from = 0;
2082 }
2083 }
2084
2085 if (!view_is_displayed(view))
2086 goto check_pipe;
2087
2088 if (view == VIEW(REQ_VIEW_TREE)) {
2089 /* Clear the view and redraw everything since the tree sorting
2090 * might have rearranged things. */
2091 redraw_view(view);
2092
2093 } else if (redraw_from >= 0) {
2094 /* If this is an incremental update, redraw the previous line
2095 * since for commits some members could have changed when
2096 * loading the main view. */
2097 if (redraw_from > 0)
2098 redraw_from--;
2099
2100 /* Since revision graph visualization requires knowledge
2101 * about the parent commit, it causes a further one-off
2102 * needed to be redrawn for incremental updates. */
2103 if (redraw_from > 0 && opt_rev_graph)
2104 redraw_from--;
2105
2106 /* Incrementally draw avoids flickering. */
2107 redraw_view_from(view, redraw_from);
2108 }
2109
2110 /* Update the title _after_ the redraw so that if the redraw picks up a
2111 * commit reference in view->ref it'll be available here. */
2112 update_view_title(view);
2113
2114 check_pipe:
2115 if (ferror(view->pipe)) {
2116 report("Failed to read: %s", strerror(errno));
2117 goto end;
2118
2119 } else if (feof(view->pipe)) {
2120 report("");
2121 goto end;
2122 }
2123
2124 return TRUE;
2125
2126 alloc_error:
2127 report("Allocation failure");
2128
2129 end:
2130 view->ops->read(view, NULL);
2131 end_update(view);
2132 return FALSE;
2133 }
2134
2135 static struct line *
2136 add_line_data(struct view *view, void *data, enum line_type type)
2137 {
2138 struct line *line = &view->line[view->lines++];
2139
2140 memset(line, 0, sizeof(*line));
2141 line->type = type;
2142 line->data = data;
2143
2144 return line;
2145 }
2146
2147 static struct line *
2148 add_line_text(struct view *view, char *data, enum line_type type)
2149 {
2150 if (data)
2151 data = strdup(data);
2152
2153 return data ? add_line_data(view, data, type) : NULL;
2154 }
2155
2156
2157 /*
2158 * View opening
2159 */
2160
2161 enum open_flags {
2162 OPEN_DEFAULT = 0, /* Use default view switching. */
2163 OPEN_SPLIT = 1, /* Split current view. */
2164 OPEN_BACKGROUNDED = 2, /* Backgrounded. */
2165 OPEN_RELOAD = 4, /* Reload view even if it is the current. */
2166 };
2167
2168 static void
2169 open_view(struct view *prev, enum request request, enum open_flags flags)
2170 {
2171 bool backgrounded = !!(flags & OPEN_BACKGROUNDED);
2172 bool split = !!(flags & OPEN_SPLIT);
2173 bool reload = !!(flags & OPEN_RELOAD);
2174 struct view *view = VIEW(request);
2175 int nviews = displayed_views();
2176 struct view *base_view = display[0];
2177
2178 if (view == prev && nviews == 1 && !reload) {
2179 report("Already in %s view", view->name);
2180 return;
2181 }
2182
2183 if (view->ops->open) {
2184 if (!view->ops->open(view)) {
2185 report("Failed to load %s view", view->name);
2186 return;
2187 }
2188
2189 } else if ((reload || strcmp(view->vid, view->id)) &&
2190 !begin_update(view)) {
2191 report("Failed to load %s view", view->name);
2192 return;
2193 }
2194
2195 if (split) {
2196 display[1] = view;
2197 if (!backgrounded)
2198 current_view = 1;
2199 } else {
2200 /* Maximize the current view. */
2201 memset(display, 0, sizeof(display));
2202 current_view = 0;
2203 display[current_view] = view;
2204 }
2205
2206 /* Resize the view when switching between split- and full-screen,
2207 * or when switching between two different full-screen views. */
2208 if (nviews != displayed_views() ||
2209 (nviews == 1 && base_view != display[0]))
2210 resize_display();
2211
2212 if (split && prev->lineno - prev->offset >= prev->height) {
2213 /* Take the title line into account. */
2214 int lines = prev->lineno - prev->offset - prev->height + 1;
2215
2216 /* Scroll the view that was split if the current line is
2217 * outside the new limited view. */
2218 do_scroll_view(prev, lines);
2219 }
2220
2221 if (prev && view != prev) {
2222 if (split && !backgrounded) {
2223 /* "Blur" the previous view. */
2224 update_view_title(prev);
2225 }
2226
2227 view->parent = prev;
2228 }
2229
2230 if (view->pipe && view->lines == 0) {
2231 /* Clear the old view and let the incremental updating refill
2232 * the screen. */
2233 wclear(view->win);
2234 report("");
2235 } else {
2236 redraw_view(view);
2237 report("");
2238 }
2239
2240 /* If the view is backgrounded the above calls to report()
2241 * won't redraw the view title. */
2242 if (backgrounded)
2243 update_view_title(view);
2244 }
2245
2246 static void
2247 open_external_viewer(const char *cmd)
2248 {
2249 def_prog_mode(); /* save current tty modes */
2250 endwin(); /* restore original tty modes */
2251 system(cmd);
2252 fprintf(stderr, "Press Enter to continue");
2253 getc(stdin);
2254 reset_prog_mode();
2255 redraw_display();
2256 }
2257
2258 static void
2259 open_mergetool(const char *file)
2260 {
2261 char cmd[SIZEOF_STR];
2262 char file_sq[SIZEOF_STR];
2263
2264 if (sq_quote(file_sq, 0, file) < sizeof(file_sq) &&
2265 string_format(cmd, "git mergetool %s", file_sq)) {
2266 open_external_viewer(cmd);
2267 }
2268 }
2269
2270 static void
2271 open_editor(bool from_root, const char *file)
2272 {
2273 char cmd[SIZEOF_STR];
2274 char file_sq[SIZEOF_STR];
2275 char *editor;
2276 char *prefix = from_root ? opt_cdup : "";
2277
2278 editor = getenv("GIT_EDITOR");
2279 if (!editor && *opt_editor)
2280 editor = opt_editor;
2281 if (!editor)
2282 editor = getenv("VISUAL");
2283 if (!editor)
2284 editor = getenv("EDITOR");
2285 if (!editor)
2286 editor = "vi";
2287
2288 if (sq_quote(file_sq, 0, file) < sizeof(file_sq) &&
2289 string_format(cmd, "%s %s%s", editor, prefix, file_sq)) {
2290 open_external_viewer(cmd);
2291 }
2292 }
2293
2294 static void
2295 open_run_request(enum request request)
2296 {
2297 struct run_request *req = get_run_request(request);
2298 char buf[SIZEOF_STR * 2];
2299 size_t bufpos;
2300 char *cmd;
2301
2302 if (!req) {
2303 report("Unknown run request");
2304 return;
2305 }
2306
2307 bufpos = 0;
2308 cmd = req->cmd;
2309
2310 while (cmd) {
2311 char *next = strstr(cmd, "%(");
2312 int len = next - cmd;
2313 char *value;
2314
2315 if (!next) {
2316 len = strlen(cmd);
2317 value = "";
2318
2319 } else if (!strncmp(next, "%(head)", 7)) {
2320 value = ref_head;
2321
2322 } else if (!strncmp(next, "%(commit)", 9)) {
2323 value = ref_commit;
2324
2325 } else if (!strncmp(next, "%(blob)", 7)) {
2326 value = ref_blob;
2327
2328 } else {
2329 report("Unknown replacement in run request: `%s`", req->cmd);
2330 return;
2331 }
2332
2333 if (!string_format_from(buf, &bufpos, "%.*s%s", len, cmd, value))
2334 return;
2335
2336 if (next)
2337 next = strchr(next, ')') + 1;
2338 cmd = next;
2339 }
2340
2341 open_external_viewer(buf);
2342 }
2343
2344 /*
2345 * User request switch noodle
2346 */
2347
2348 static int
2349 view_driver(struct view *view, enum request request)
2350 {
2351 int i;
2352
2353 if (request == REQ_NONE) {
2354 doupdate();
2355 return TRUE;
2356 }
2357
2358 if (request > REQ_NONE) {
2359 open_run_request(request);
2360 return TRUE;
2361 }
2362
2363 if (view && view->lines) {
2364 request = view->ops->request(view, request, &view->line[view->lineno]);
2365 if (request == REQ_NONE)
2366 return TRUE;
2367 }
2368
2369 switch (request) {
2370 case REQ_MOVE_UP:
2371 case REQ_MOVE_DOWN:
2372 case REQ_MOVE_PAGE_UP:
2373 case REQ_MOVE_PAGE_DOWN:
2374 case REQ_MOVE_FIRST_LINE:
2375 case REQ_MOVE_LAST_LINE:
2376 move_view(view, request);
2377 break;
2378
2379 case REQ_SCROLL_LINE_DOWN:
2380 case REQ_SCROLL_LINE_UP:
2381 case REQ_SCROLL_PAGE_DOWN:
2382 case REQ_SCROLL_PAGE_UP:
2383 scroll_view(view, request);
2384 break;
2385
2386 case REQ_VIEW_BLOB:
2387 if (!ref_blob[0]) {
2388 report("No file chosen, press %s to open tree view",
2389 get_key(REQ_VIEW_TREE));
2390 break;
2391 }
2392 open_view(view, request, OPEN_DEFAULT);
2393 break;
2394
2395 case REQ_VIEW_PAGER:
2396 if (!opt_pipe && !VIEW(REQ_VIEW_PAGER)->lines) {
2397 report("No pager content, press %s to run command from prompt",
2398 get_key(REQ_PROMPT));
2399 break;
2400 }
2401 open_view(view, request, OPEN_DEFAULT);
2402 break;
2403
2404 case REQ_VIEW_STAGE:
2405 if (!VIEW(REQ_VIEW_STAGE)->lines) {
2406 report("No stage content, press %s to open the status view and choose file",
2407 get_key(REQ_VIEW_STATUS));
2408 break;
2409 }
2410 open_view(view, request, OPEN_DEFAULT);
2411 break;
2412
2413 case REQ_VIEW_STATUS:
2414 if (opt_is_inside_work_tree == FALSE) {
2415 report("The status view requires a working tree");
2416 break;
2417 }
2418 open_view(view, request, OPEN_DEFAULT);
2419 break;
2420
2421 case REQ_VIEW_MAIN:
2422 case REQ_VIEW_DIFF:
2423 case REQ_VIEW_LOG:
2424 case REQ_VIEW_TREE:
2425 case REQ_VIEW_HELP:
2426 open_view(view, request, OPEN_DEFAULT);
2427 break;
2428
2429 case REQ_NEXT:
2430 case REQ_PREVIOUS:
2431 request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
2432
2433 if ((view == VIEW(REQ_VIEW_DIFF) &&
2434 view->parent == VIEW(REQ_VIEW_MAIN)) ||
2435 (view == VIEW(REQ_VIEW_STAGE) &&
2436 view->parent == VIEW(REQ_VIEW_STATUS)) ||
2437 (view == VIEW(REQ_VIEW_BLOB) &&
2438 view->parent == VIEW(REQ_VIEW_TREE))) {
2439 int line;
2440
2441 view = view->parent;
2442 line = view->lineno;
2443 move_view(view, request);
2444 if (view_is_displayed(view))
2445 update_view_title(view);
2446 if (line != view->lineno)
2447 view->ops->request(view, REQ_ENTER,
2448 &view->line[view->lineno]);
2449
2450 } else {
2451 move_view(view, request);
2452 }
2453 break;
2454
2455 case REQ_VIEW_NEXT:
2456 {
2457 int nviews = displayed_views();
2458 int next_view = (current_view + 1) % nviews;
2459
2460 if (next_view == current_view) {
2461 report("Only one view is displayed");
2462 break;
2463 }
2464
2465 current_view = next_view;
2466 /* Blur out the title of the previous view. */
2467 update_view_title(view);
2468 report("");
2469 break;
2470 }
2471 case REQ_REFRESH:
2472 report("Refreshing is not yet supported for the %s view", view->name);
2473 break;
2474
2475 case REQ_TOGGLE_LINENO:
2476 opt_line_number = !opt_line_number;
2477 redraw_display();
2478 break;
2479
2480 case REQ_TOGGLE_REV_GRAPH:
2481 opt_rev_graph = !opt_rev_graph;
2482 redraw_display();
2483 break;
2484
2485 case REQ_PROMPT:
2486 /* Always reload^Wrerun commands from the prompt. */
2487 open_view(view, opt_request, OPEN_RELOAD);
2488 break;
2489
2490 case REQ_SEARCH:
2491 case REQ_SEARCH_BACK:
2492 search_view(view, request);
2493 break;
2494
2495 case REQ_FIND_NEXT:
2496 case REQ_FIND_PREV:
2497 find_next(view, request);
2498 break;
2499
2500 case REQ_STOP_LOADING:
2501 for (i = 0; i < ARRAY_SIZE(views); i++) {
2502 view = &views[i];
2503 if (view->pipe)
2504 report("Stopped loading the %s view", view->name),
2505 end_update(view);
2506 }
2507 break;
2508
2509 case REQ_SHOW_VERSION:
2510 report("tig-%s (built %s)", TIG_VERSION, __DATE__);
2511 return TRUE;
2512
2513 case REQ_SCREEN_RESIZE:
2514 resize_display();
2515 /* Fall-through */
2516 case REQ_SCREEN_REDRAW:
2517 redraw_display();
2518 break;
2519
2520 case REQ_EDIT:
2521 report("Nothing to edit");
2522 break;
2523
2524
2525 case REQ_ENTER:
2526 report("Nothing to enter");
2527 break;
2528
2529
2530 case REQ_VIEW_CLOSE:
2531 /* XXX: Mark closed views by letting view->parent point to the
2532 * view itself. Parents to closed view should never be
2533 * followed. */
2534 if (view->parent &&
2535 view->parent->parent != view->parent) {
2536 memset(display, 0, sizeof(display));
2537 current_view = 0;
2538 display[current_view] = view->parent;
2539 view->parent = view;
2540 resize_display();
2541 redraw_display();
2542 break;
2543 }
2544 /* Fall-through */
2545 case REQ_QUIT:
2546 return FALSE;
2547
2548 default:
2549 /* An unknown key will show most commonly used commands. */
2550 report("Unknown key, press 'h' for help");
2551 return TRUE;
2552 }
2553
2554 return TRUE;
2555 }
2556
2557
2558 /*
2559 * Pager backend
2560 */
2561
2562 static bool
2563 pager_draw(struct view *view, struct line *line, unsigned int lineno, bool selected)
2564 {
2565 char *text = line->data;
2566 enum line_type type = line->type;
2567 int textlen = strlen(text);
2568 int attr;
2569
2570 wmove(view->win, lineno, 0);
2571
2572 if (selected) {
2573 type = LINE_CURSOR;
2574 wchgat(view->win, -1, 0, type, NULL);
2575 }
2576
2577 attr = get_line_attr(type);
2578 wattrset(view->win, attr);
2579
2580 if (opt_line_number || opt_tab_size < TABSIZE) {
2581 static char spaces[] = " ";
2582 int col_offset = 0, col = 0;
2583
2584 if (opt_line_number) {
2585 unsigned long real_lineno = view->offset + lineno + 1;
2586
2587 if (real_lineno == 1 ||
2588 (real_lineno % opt_num_interval) == 0) {
2589 wprintw(view->win, "%.*d", view->digits, real_lineno);
2590
2591 } else {
2592 waddnstr(view->win, spaces,
2593 MIN(view->digits, STRING_SIZE(spaces)));
2594 }
2595 waddstr(view->win, ": ");
2596 col_offset = view->digits + 2;
2597 }
2598
2599 while (text && col_offset + col < view->width) {
2600 int cols_max = view->width - col_offset - col;
2601 char *pos = text;
2602 int cols;
2603
2604 if (*text == '\t') {
2605 text++;
2606 assert(sizeof(spaces) > TABSIZE);
2607 pos = spaces;
2608 cols = opt_tab_size - (col % opt_tab_size);
2609
2610 } else {
2611 text = strchr(text, '\t');
2612 cols = line ? text - pos : strlen(pos);
2613 }
2614
2615 waddnstr(view->win, pos, MIN(cols, cols_max));
2616 col += cols;
2617 }
2618
2619 } else {
2620 int col = 0, pos = 0;
2621
2622 for (; pos < textlen && col < view->width; pos++, col++)
2623 if (text[pos] == '\t')
2624 col += TABSIZE - (col % TABSIZE) - 1;
2625
2626 waddnstr(view->win, text, pos);
2627 }
2628
2629 return TRUE;
2630 }
2631
2632 static bool
2633 add_describe_ref(char *buf, size_t *bufpos, char *commit_id, const char *sep)
2634 {
2635 char refbuf[SIZEOF_STR];
2636 char *ref = NULL;
2637 FILE *pipe;
2638
2639 if (!string_format(refbuf, "git describe %s 2>/dev/null", commit_id))
2640 return TRUE;
2641
2642 pipe = popen(refbuf, "r");
2643 if (!pipe)
2644 return TRUE;
2645
2646 if ((ref = fgets(refbuf, sizeof(refbuf), pipe)))
2647 ref = chomp_string(ref);
2648 pclose(pipe);
2649
2650 if (!ref || !*ref)
2651 return TRUE;
2652
2653 /* This is the only fatal call, since it can "corrupt" the buffer. */
2654 if (!string_nformat(buf, SIZEOF_STR, bufpos, "%s%s", sep, ref))
2655 return FALSE;
2656
2657 return TRUE;
2658 }
2659
2660 static void
2661 add_pager_refs(struct view *view, struct line *line)
2662 {
2663 char buf[SIZEOF_STR];
2664 char *commit_id = line->data + STRING_SIZE("commit ");
2665 struct ref **refs;
2666 size_t bufpos = 0, refpos = 0;
2667 const char *sep = "Refs: ";
2668 bool is_tag = FALSE;
2669
2670 assert(line->type == LINE_COMMIT);
2671
2672 refs = get_refs(commit_id);
2673 if (!refs) {
2674 if (view == VIEW(REQ_VIEW_DIFF))
2675 goto try_add_describe_ref;
2676 return;
2677 }
2678
2679 do {
2680 struct ref *ref = refs[refpos];
2681 char *fmt = ref->tag ? "%s[%s]" :
2682 ref->remote ? "%s<%s>" : "%s%s";
2683
2684 if (!string_format_from(buf, &bufpos, fmt, sep, ref->name))
2685 return;
2686 sep = ", ";
2687 if (ref->tag)
2688 is_tag = TRUE;
2689 } while (refs[refpos++]->next);
2690
2691 if (!is_tag && view == VIEW(REQ_VIEW_DIFF)) {
2692 try_add_describe_ref:
2693 /* Add <tag>-g<commit_id> "fake" reference. */
2694 if (!add_describe_ref(buf, &bufpos, commit_id, sep))
2695 return;
2696 }
2697
2698 if (bufpos == 0)
2699 return;
2700
2701 if (!realloc_lines(view, view->line_size + 1))
2702 return;
2703
2704 add_line_text(view, buf, LINE_PP_REFS);
2705 }
2706
2707 static bool
2708 pager_read(struct view *view, char *data)
2709 {
2710 struct line *line;
2711
2712 if (!data)
2713 return TRUE;
2714
2715 line = add_line_text(view, data, get_line_type(data));
2716 if (!line)
2717 return FALSE;
2718
2719 if (line->type == LINE_COMMIT &&
2720 (view == VIEW(REQ_VIEW_DIFF) ||
2721 view == VIEW(REQ_VIEW_LOG)))
2722 add_pager_refs(view, line);
2723
2724 return TRUE;
2725 }
2726
2727 static enum request
2728 pager_request(struct view *view, enum request request, struct line *line)
2729 {
2730 int split = 0;
2731
2732 if (request != REQ_ENTER)
2733 return request;
2734
2735 if (line->type == LINE_COMMIT &&
2736 (view == VIEW(REQ_VIEW_LOG) ||
2737 view == VIEW(REQ_VIEW_PAGER))) {
2738 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
2739 split = 1;
2740 }
2741
2742 /* Always scroll the view even if it was split. That way
2743 * you can use Enter to scroll through the log view and
2744 * split open each commit diff. */
2745 scroll_view(view, REQ_SCROLL_LINE_DOWN);
2746
2747 /* FIXME: A minor workaround. Scrolling the view will call report("")
2748 * but if we are scrolling a non-current view this won't properly
2749 * update the view title. */
2750 if (split)
2751 update_view_title(view);
2752
2753 return REQ_NONE;
2754 }
2755
2756 static bool
2757 pager_grep(struct view *view, struct line *line)
2758 {
2759 regmatch_t pmatch;
2760 char *text = line->data;
2761
2762 if (!*text)
2763 return FALSE;
2764
2765 if (regexec(view->regex, text, 1, &pmatch, 0) == REG_NOMATCH)
2766 return FALSE;
2767
2768 return TRUE;
2769 }
2770
2771 static void
2772 pager_select(struct view *view, struct line *line)
2773 {
2774 if (line->type == LINE_COMMIT) {
2775 char *text = line->data + STRING_SIZE("commit ");
2776
2777 if (view != VIEW(REQ_VIEW_PAGER))
2778 string_copy_rev(view->ref, text);
2779 string_copy_rev(ref_commit, text);
2780 }
2781 }
2782
2783 static struct view_ops pager_ops = {
2784 "line",
2785 NULL,
2786 pager_read,
2787 pager_draw,
2788 pager_request,
2789 pager_grep,
2790 pager_select,
2791 };
2792
2793
2794 /*
2795 * Help backend
2796 */
2797
2798 static bool
2799 help_open(struct view *view)
2800 {
2801 char buf[BUFSIZ];
2802 int lines = ARRAY_SIZE(req_info) + 2;
2803 int i;
2804
2805 if (view->lines > 0)
2806 return TRUE;
2807
2808 for (i = 0; i < ARRAY_SIZE(req_info); i++)
2809 if (!req_info[i].request)
2810 lines++;
2811
2812 lines += run_requests + 1;
2813
2814 view->line = calloc(lines, sizeof(*view->line));
2815 if (!view->line)
2816 return FALSE;
2817
2818 add_line_text(view, "Quick reference for tig keybindings:", LINE_DEFAULT);
2819
2820 for (i = 0; i < ARRAY_SIZE(req_info); i++) {
2821 char *key;
2822
2823 if (req_info[i].request == REQ_NONE)
2824 continue;
2825
2826 if (!req_info[i].request) {
2827 add_line_text(view, "", LINE_DEFAULT);
2828 add_line_text(view, req_info[i].help, LINE_DEFAULT);
2829 continue;
2830 }
2831
2832 key = get_key(req_info[i].request);
2833 if (!*key)
2834 key = "(no key defined)";
2835
2836 if (!string_format(buf, " %-25s %s", key, req_info[i].help))
2837 continue;
2838
2839 add_line_text(view, buf, LINE_DEFAULT);
2840 }
2841
2842 if (run_requests) {
2843 add_line_text(view, "", LINE_DEFAULT);
2844 add_line_text(view, "External commands:", LINE_DEFAULT);
2845 }
2846
2847 for (i = 0; i < run_requests; i++) {
2848 struct run_request *req = get_run_request(REQ_NONE + i + 1);
2849 char *key;
2850
2851 if (!req)
2852 continue;
2853
2854 key = get_key_name(req->key);
2855 if (!*key)
2856 key = "(no key defined)";
2857
2858 if (!string_format(buf, " %-10s %-14s `%s`",
2859 keymap_table[req->keymap].name,
2860 key, req->cmd))
2861 continue;
2862
2863 add_line_text(view, buf, LINE_DEFAULT);
2864 }
2865
2866 return TRUE;
2867 }
2868
2869 static struct view_ops help_ops = {
2870 "line",
2871 help_open,
2872 NULL,
2873 pager_draw,
2874 pager_request,
2875 pager_grep,
2876 pager_select,
2877 };
2878
2879
2880 /*
2881 * Tree backend
2882 */
2883
2884 struct tree_stack_entry {
2885 struct tree_stack_entry *prev; /* Entry below this in the stack */
2886 unsigned long lineno; /* Line number to restore */
2887 char *name; /* Position of name in opt_path */
2888 };
2889
2890 /* The top of the path stack. */
2891 static struct tree_stack_entry *tree_stack = NULL;
2892 unsigned long tree_lineno = 0;
2893
2894 static void
2895 pop_tree_stack_entry(void)
2896 {
2897 struct tree_stack_entry *entry = tree_stack;
2898
2899 tree_lineno = entry->lineno;
2900 entry->name[0] = 0;
2901 tree_stack = entry->prev;
2902 free(entry);
2903 }
2904
2905 static void
2906 push_tree_stack_entry(char *name, unsigned long lineno)
2907 {
2908 struct tree_stack_entry *entry = calloc(1, sizeof(*entry));
2909 size_t pathlen = strlen(opt_path);
2910
2911 if (!entry)
2912 return;
2913
2914 entry->prev = tree_stack;
2915 entry->name = opt_path + pathlen;
2916 tree_stack = entry;
2917
2918 if (!string_format_from(opt_path, &pathlen, "%s/", name)) {
2919 pop_tree_stack_entry();
2920 return;
2921 }
2922
2923 /* Move the current line to the first tree entry. */
2924 tree_lineno = 1;
2925 entry->lineno = lineno;
2926 }
2927
2928 /* Parse output from git-ls-tree(1):
2929 *
2930 * 100644 blob fb0e31ea6cc679b7379631188190e975f5789c26 Makefile
2931 * 100644 blob 5304ca4260aaddaee6498f9630e7d471b8591ea6 README
2932 * 100644 blob f931e1d229c3e185caad4449bf5b66ed72462657 tig.c
2933 * 100644 blob ed09fe897f3c7c9af90bcf80cae92558ea88ae38 web.conf
2934 */
2935
2936 #define SIZEOF_TREE_ATTR \
2937 STRING_SIZE("100644 blob ed09fe897f3c7c9af90bcf80cae92558ea88ae38\t")
2938
2939 #define TREE_UP_FORMAT "040000 tree %s\t.."
2940
2941 static int
2942 tree_compare_entry(enum line_type type1, char *name1,
2943 enum line_type type2, char *name2)
2944 {
2945 if (type1 != type2) {
2946 if (type1 == LINE_TREE_DIR)
2947 return -1;
2948 return 1;
2949 }
2950
2951 return strcmp(name1, name2);
2952 }
2953
2954 static bool
2955 tree_read(struct view *view, char *text)
2956 {
2957 size_t textlen = text ? strlen(text) : 0;
2958 char buf[SIZEOF_STR];
2959 unsigned long pos;
2960 enum line_type type;
2961 bool first_read = view->lines == 0;
2962
2963 if (textlen <= SIZEOF_TREE_ATTR)
2964 return FALSE;
2965
2966 type = text[STRING_SIZE("100644 ")] == 't'
2967 ? LINE_TREE_DIR : LINE_TREE_FILE;
2968
2969 if (first_read) {
2970 /* Add path info line */
2971 if (!string_format(buf, "Directory path /%s", opt_path) ||
2972 !realloc_lines(view, view->line_size + 1) ||
2973 !add_line_text(view, buf, LINE_DEFAULT))
2974 return FALSE;
2975
2976 /* Insert "link" to parent directory. */
2977 if (*opt_path) {
2978 if (!string_format(buf, TREE_UP_FORMAT, view->ref) ||
2979 !realloc_lines(view, view->line_size + 1) ||
2980 !add_line_text(view, buf, LINE_TREE_DIR))
2981 return FALSE;
2982 }
2983 }
2984
2985 /* Strip the path part ... */
2986 if (*opt_path) {
2987 size_t pathlen = textlen - SIZEOF_TREE_ATTR;
2988 size_t striplen = strlen(opt_path);
2989 char *path = text + SIZEOF_TREE_ATTR;
2990
2991 if (pathlen > striplen)
2992 memmove(path, path + striplen,
2993 pathlen - striplen + 1);
2994 }
2995
2996 /* Skip "Directory ..." and ".." line. */
2997 for (pos = 1 + !!*opt_path; pos < view->lines; pos++) {
2998 struct line *line = &view->line[pos];
2999 char *path1 = ((char *) line->data) + SIZEOF_TREE_ATTR;
3000 char *path2 = text + SIZEOF_TREE_ATTR;
3001 int cmp = tree_compare_entry(line->type, path1, type, path2);
3002
3003 if (cmp <= 0)
3004 continue;
3005
3006 text = strdup(text);
3007 if (!text)
3008 return FALSE;
3009
3010 if (view->lines > pos)
3011 memmove(&view->line[pos + 1], &view->line[pos],
3012 (view->lines - pos) * sizeof(*line));
3013
3014 line = &view->line[pos];
3015 line->data = text;
3016 line->type = type;
3017 view->lines++;
3018 return TRUE;
3019 }
3020
3021 if (!add_line_text(view, text, type))
3022 return FALSE;
3023
3024 if (tree_lineno > view->lineno) {
3025 view->lineno = tree_lineno;
3026 tree_lineno = 0;
3027 }
3028
3029 return TRUE;
3030 }
3031
3032 static enum request
3033 tree_request(struct view *view, enum request request, struct line *line)
3034 {
3035 enum open_flags flags;
3036
3037 if (request != REQ_ENTER)
3038 return request;
3039
3040 /* Cleanup the stack if the tree view is at a different tree. */
3041 while (!*opt_path && tree_stack)
3042 pop_tree_stack_entry();
3043
3044 switch (line->type) {
3045 case LINE_TREE_DIR:
3046 /* Depending on whether it is a subdir or parent (updir?) link
3047 * mangle the path buffer. */
3048 if (line == &view->line[1] && *opt_path) {
3049 pop_tree_stack_entry();
3050
3051 } else {
3052 char *data = line->data;
3053 char *basename = data + SIZEOF_TREE_ATTR;
3054
3055 push_tree_stack_entry(basename, view->lineno);
3056 }
3057
3058 /* Trees and subtrees share the same ID, so they are not not
3059 * unique like blobs. */
3060 flags = OPEN_RELOAD;
3061 request = REQ_VIEW_TREE;
3062 break;
3063
3064 case LINE_TREE_FILE:
3065 flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
3066 request = REQ_VIEW_BLOB;
3067 break;
3068
3069 default:
3070 return TRUE;
3071 }
3072
3073 open_view(view, request, flags);
3074 if (request == REQ_VIEW_TREE) {
3075 view->lineno = tree_lineno;
3076 }
3077
3078 return REQ_NONE;
3079 }
3080
3081 static void
3082 tree_select(struct view *view, struct line *line)
3083 {
3084 char *text = line->data + STRING_SIZE("100644 blob ");
3085
3086 if (line->type == LINE_TREE_FILE) {
3087 string_copy_rev(ref_blob, text);
3088
3089 } else if (line->type != LINE_TREE_DIR) {
3090 return;
3091 }
3092
3093 string_copy_rev(view->ref, text);
3094 }
3095
3096 static struct view_ops tree_ops = {
3097 "file",
3098 NULL,
3099 tree_read,
3100 pager_draw,
3101 tree_request,
3102 pager_grep,
3103 tree_select,
3104 };
3105
3106 static bool
3107 blob_read(struct view *view, char *line)
3108 {
3109 return add_line_text(view, line, LINE_DEFAULT) != NULL;
3110 }
3111
3112 static struct view_ops blob_ops = {
3113 "line",
3114 NULL,
3115 blob_read,
3116 pager_draw,
3117 pager_request,
3118 pager_grep,
3119 pager_select,
3120 };
3121
3122
3123 /*
3124 * Status backend
3125 */
3126
3127 struct status {
3128 char status;
3129 struct {
3130 mode_t mode;
3131 char rev[SIZEOF_REV];
3132 } old;
3133 struct {
3134 mode_t mode;
3135 char rev[SIZEOF_REV];
3136 } new;
3137 char name[SIZEOF_STR];
3138 };
3139
3140 static struct status stage_status;
3141 static enum line_type stage_line_type;
3142
3143 /* Get fields from the diff line:
3144 * :100644 100644 06a5d6ae9eca55be2e0e585a152e6b1336f2b20e 0000000000000000000000000000000000000000 M
3145 */
3146 static inline bool
3147 status_get_diff(struct status *file, char *buf, size_t bufsize)
3148 {
3149 char *old_mode = buf + 1;
3150 char *new_mode = buf + 8;
3151 char *old_rev = buf + 15;
3152 char *new_rev = buf + 56;
3153 char *status = buf + 97;
3154
3155 if (bufsize != 99 ||
3156 old_mode[-1] != ':' ||
3157 new_mode[-1] != ' ' ||
3158 old_rev[-1] != ' ' ||
3159 new_rev[-1] != ' ' ||
3160 status[-1] != ' ')
3161 return FALSE;
3162
3163 file->status = *status;
3164
3165 string_copy_rev(file->old.rev, old_rev);
3166 string_copy_rev(file->new.rev, new_rev);
3167
3168 file->old.mode = strtoul(old_mode, NULL, 8);
3169 file->new.mode = strtoul(new_mode, NULL, 8);
3170
3171 file->name[0] = 0;
3172
3173 return TRUE;
3174 }
3175
3176 static bool
3177 status_run(struct view *view, const char cmd[], bool diff, enum line_type type)
3178 {
3179 struct status *file = NULL;
3180 struct status *unmerged = NULL;
3181 char buf[SIZEOF_STR * 4];
3182 size_t bufsize = 0;
3183 FILE *pipe;
3184
3185 pipe = popen(cmd, "r");
3186 if (!pipe)
3187 return FALSE;
3188
3189 add_line_data(view, NULL, type);
3190
3191 while (!feof(pipe) && !ferror(pipe)) {
3192 char *sep;
3193 size_t readsize;
3194
3195 readsize = fread(buf + bufsize, 1, sizeof(buf) - bufsize, pipe);
3196 if (!readsize)
3197 break;
3198 bufsize += readsize;
3199
3200 /* Process while we have NUL chars. */
3201 while ((sep = memchr(buf, 0, bufsize))) {
3202 size_t sepsize = sep - buf + 1;
3203
3204 if (!file) {
3205 if (!realloc_lines(view, view->line_size + 1))
3206 goto error_out;
3207
3208 file = calloc(1, sizeof(*file));
3209 if (!file)
3210 goto error_out;
3211
3212 add_line_data(view, file, type);
3213 }
3214
3215 /* Parse diff info part. */
3216 if (!diff) {
3217 file->status = '?';
3218
3219 } else if (!file->status) {
3220 if (!status_get_diff(file, buf, sepsize))
3221 goto error_out;
3222
3223 bufsize -= sepsize;
3224 memmove(buf, sep + 1, bufsize);
3225
3226 sep = memchr(buf, 0, bufsize);
3227 if (!sep)
3228 break;
3229 sepsize = sep - buf + 1;
3230
3231 /* Collapse all 'M'odified entries that
3232 * follow a associated 'U'nmerged entry.
3233 */
3234 if (file->status == 'U') {
3235 unmerged = file;
3236
3237 } else if (unmerged) {
3238 int collapse = !strcmp(buf, unmerged->name);
3239
3240 unmerged = NULL;
3241 if (collapse) {
3242 free(file);
3243 view->lines--;
3244 continue;
3245 }
3246 }
3247 }
3248
3249 /* git-ls-files just delivers a NUL separated
3250 * list of file names similar to the second half
3251 * of the git-diff-* output. */
3252 string_ncopy(file->name, buf, sepsize);
3253 bufsize -= sepsize;
3254 memmove(buf, sep + 1, bufsize);
3255 file = NULL;
3256 }
3257 }
3258
3259 if (ferror(pipe)) {
3260 error_out:
3261 pclose(pipe);
3262 return FALSE;
3263 }
3264
3265 if (!view->line[view->lines - 1].data)
3266 add_line_data(view, NULL, LINE_STAT_NONE);
3267
3268 pclose(pipe);
3269 return TRUE;
3270 }
3271
3272 /* Don't show unmerged entries in the staged section. */
3273 #define STATUS_DIFF_INDEX_CMD "git diff-index -z --diff-filter=ACDMRTXB --cached HEAD"
3274 #define STATUS_DIFF_FILES_CMD "git diff-files -z"
3275 #define STATUS_LIST_OTHER_CMD \
3276 "git ls-files -z --others --exclude-per-directory=.gitignore"
3277
3278 #define STATUS_DIFF_SHOW_CMD \
3279 "git diff --root --patch-with-stat --find-copies-harder -B -C %s -- %s 2>/dev/null"
3280
3281 /* First parse staged info using git-diff-index(1), then parse unstaged
3282 * info using git-diff-files(1), and finally untracked files using
3283 * git-ls-files(1). */
3284 static bool
3285 status_open(struct view *view)
3286 {
3287 struct stat statbuf;
3288 char exclude[SIZEOF_STR];
3289 char cmd[SIZEOF_STR];
3290 unsigned long prev_lineno = view->lineno;
3291 size_t i;
3292
3293 for (i = 0; i < view->lines; i++)
3294 free(view->line[i].data);
3295 free(view->line);
3296 view->lines = view->line_size = view->lineno = 0;
3297 view->line = NULL;
3298
3299 if (!realloc_lines(view, view->line_size + 6))
3300 return FALSE;
3301
3302 if (!string_format(exclude, "%s/info/exclude", opt_git_dir))
3303 return FALSE;
3304
3305 string_copy(cmd, STATUS_LIST_OTHER_CMD);
3306
3307 if (stat(exclude, &statbuf) >= 0) {
3308 size_t cmdsize = strlen(cmd);
3309
3310 if (!string_format_from(cmd, &cmdsize, " %s", "--exclude-from=") ||
3311 sq_quote(cmd, cmdsize, exclude) >= sizeof(cmd))
3312 return FALSE;
3313 }
3314
3315 if (!status_run(view, STATUS_DIFF_INDEX_CMD, TRUE, LINE_STAT_STAGED) ||
3316 !status_run(view, STATUS_DIFF_FILES_CMD, TRUE, LINE_STAT_UNSTAGED) ||
3317 !status_run(view, cmd, FALSE, LINE_STAT_UNTRACKED))
3318 return FALSE;
3319
3320 /* If all went well restore the previous line number to stay in
3321 * the context. */
3322 if (prev_lineno < view->lines)
3323 view->lineno = prev_lineno;
3324 else
3325 view->lineno = view->lines - 1;
3326
3327 return TRUE;
3328 }
3329
3330 static bool
3331 status_draw(struct view *view, struct line *line, unsigned int lineno, bool selected)
3332 {
3333 struct status *status = line->data;
3334
3335 wmove(view->win, lineno, 0);
3336
3337 if (selected) {
3338 wattrset(view->win, get_line_attr(LINE_CURSOR));
3339 wchgat(view->win, -1, 0, LINE_CURSOR, NULL);
3340
3341 } else if (!status && line->type != LINE_STAT_NONE) {
3342 wattrset(view->win, get_line_attr(LINE_STAT_SECTION));
3343 wchgat(view->win, -1, 0, LINE_STAT_SECTION, NULL);
3344
3345 } else {
3346 wattrset(view->win, get_line_attr(line->type));
3347 }
3348
3349 if (!status) {
3350 char *text;
3351
3352 switch (line->type) {
3353 case LINE_STAT_STAGED:
3354 text = "Changes to be committed:";
3355 break;
3356
3357 case LINE_STAT_UNSTAGED:
3358 text = "Changed but not updated:";
3359 break;
3360
3361 case LINE_STAT_UNTRACKED:
3362 text = "Untracked files:";
3363 break;
3364
3365 case LINE_STAT_NONE:
3366 text = " (no files)";
3367 break;
3368
3369 default:
3370 return FALSE;
3371 }
3372
3373 waddstr(view->win, text);
3374 return TRUE;
3375 }
3376
3377 waddch(view->win, status->status);
3378 if (!selected)
3379 wattrset(view->win, A_NORMAL);
3380 wmove(view->win, lineno, 4);
3381 waddstr(view->win, status->name);
3382
3383 return TRUE;
3384 }
3385
3386 static enum request
3387 status_enter(struct view *view, struct line *line)
3388 {
3389 struct status *status = line->data;
3390 char path[SIZEOF_STR] = "";
3391 char *info;
3392 size_t cmdsize = 0;
3393
3394 if (line->type == LINE_STAT_NONE ||
3395 (!status && line[1].type == LINE_STAT_NONE)) {
3396 report("No file to diff");
3397 return REQ_NONE;
3398 }
3399
3400 if (status && sq_quote(path, 0, status->name) >= sizeof(path))
3401 return REQ_QUIT;
3402
3403 if (opt_cdup[0] &&
3404 line->type != LINE_STAT_UNTRACKED &&
3405 !string_format_from(opt_cmd, &cmdsize, "cd %s;", opt_cdup))
3406 return REQ_QUIT;
3407
3408 switch (line->type) {
3409 case LINE_STAT_STAGED:
3410 if (!string_format_from(opt_cmd, &cmdsize, STATUS_DIFF_SHOW_CMD,
3411 "--cached", path))
3412 return REQ_QUIT;
3413 if (status)
3414 info = "Staged changes to %s";
3415 else
3416 info = "Staged changes";
3417 break;
3418
3419 case LINE_STAT_UNSTAGED:
3420 if (!string_format_from(opt_cmd, &cmdsize, STATUS_DIFF_SHOW_CMD,
3421 "", path))
3422 return REQ_QUIT;
3423 if (status)
3424 info = "Unstaged changes to %s";
3425 else
3426 info = "Unstaged changes";
3427 break;
3428
3429 case LINE_STAT_UNTRACKED:
3430 if (opt_pipe)
3431 return REQ_QUIT;
3432
3433
3434 if (!status) {
3435 report("No file to show");
3436 return REQ_NONE;
3437 }
3438
3439 opt_pipe = fopen(status->name, "r");
3440 info = "Untracked file %s";
3441 break;
3442
3443 default:
3444 die("w00t");
3445 }
3446
3447 open_view(view, REQ_VIEW_STAGE, OPEN_RELOAD | OPEN_SPLIT);
3448 if (view_is_displayed(VIEW(REQ_VIEW_STAGE))) {
3449 if (status) {
3450 stage_status = *status;
3451 } else {
3452 memset(&stage_status, 0, sizeof(stage_status));
3453 }
3454
3455 stage_line_type = line->type;
3456 string_format(VIEW(REQ_VIEW_STAGE)->ref, info, stage_status.name);
3457 }
3458
3459 return REQ_NONE;
3460 }
3461
3462
3463 static bool
3464 status_update_file(struct view *view, struct status *status, enum line_type type)
3465 {
3466 char cmd[SIZEOF_STR];
3467 char buf[SIZEOF_STR];
3468 size_t cmdsize = 0;
3469 size_t bufsize = 0;
3470 size_t written = 0;
3471 FILE *pipe;
3472
3473 if (opt_cdup[0] &&
3474 type != LINE_STAT_UNTRACKED &&
3475 !string_format_from(cmd, &cmdsize, "cd %s;", opt_cdup))
3476 return FALSE;
3477
3478 switch (type) {
3479 case LINE_STAT_STAGED:
3480 if (!string_format_from(buf, &bufsize, "%06o %s\t%s%c",
3481 status->old.mode,
3482 status->old.rev,
3483 status->name, 0))
3484 return FALSE;
3485
3486 string_add(cmd, cmdsize, "git update-index -z --index-info");
3487 break;
3488
3489 case LINE_STAT_UNSTAGED:
3490 case LINE_STAT_UNTRACKED:
3491 if (!string_format_from(buf, &bufsize, "%s%c", status->name, 0))
3492 return FALSE;
3493
3494 string_add(cmd, cmdsize, "git update-index -z --add --remove --stdin");
3495 break;
3496
3497 default:
3498 die("w00t");
3499 }
3500
3501 pipe = popen(cmd, "w");
3502 if (!pipe)
3503 return FALSE;
3504
3505 while (!ferror(pipe) && written < bufsize) {
3506 written += fwrite(buf + written, 1, bufsize - written, pipe);
3507 }
3508
3509 pclose(pipe);
3510
3511 if (written != bufsize)
3512 return FALSE;
3513
3514 return TRUE;
3515 }
3516
3517 static void
3518 status_update(struct view *view)
3519 {
3520 struct line *line = &view->line[view->lineno];
3521
3522 assert(view->lines);
3523
3524 if (!line->data) {
3525 while (++line < view->line + view->lines && line->data) {
3526 if (!status_update_file(view, line->data, line->type))
3527 report("Failed to update file status");
3528 }
3529
3530 if (!line[-1].data) {
3531 report("Nothing to update");
3532 return;
3533 }
3534
3535 } else if (!status_update_file(view, line->data, line->type)) {
3536 report("Failed to update file status");
3537 }
3538 }
3539
3540 static enum request
3541 status_request(struct view *view, enum request request, struct line *line)
3542 {
3543 struct status *status = line->data;
3544
3545 switch (request) {
3546 case REQ_STATUS_UPDATE:
3547 status_update(view);
3548 break;
3549
3550 case REQ_STATUS_MERGE:
3551 open_mergetool(status->name);
3552 break;
3553
3554 case REQ_EDIT:
3555 if (!status)
3556 return request;
3557
3558 open_editor(status->status != '?', status->name);
3559 break;
3560
3561 case REQ_ENTER:
3562 /* After returning the status view has been split to
3563 * show the stage view. No further reloading is
3564 * necessary. */
3565 status_enter(view, line);
3566 return REQ_NONE;
3567
3568 case REQ_REFRESH:
3569 /* Simply reload the view. */
3570 break;
3571
3572 default:
3573 return request;
3574 }
3575
3576 open_view(view, REQ_VIEW_STATUS, OPEN_RELOAD);
3577
3578 return REQ_NONE;
3579 }
3580
3581 static void
3582 status_select(struct view *view, struct line *line)
3583 {
3584 struct status *status = line->data;
3585 char file[SIZEOF_STR] = "all files";
3586 char *text;
3587 char *key;
3588
3589 if (status && !string_format(file, "'%s'", status->name))
3590 return;
3591
3592 if (!status && line[1].type == LINE_STAT_NONE)
3593 line++;
3594
3595 switch (line->type) {
3596 case LINE_STAT_STAGED:
3597 text = "Press %s to unstage %s for commit";
3598 break;
3599
3600 case LINE_STAT_UNSTAGED:
3601 text = "Press %s to stage %s for commit";
3602 break;
3603
3604 case LINE_STAT_UNTRACKED:
3605 text = "Press %s to stage %s for addition";
3606 break;
3607
3608 case LINE_STAT_NONE:
3609 text = "Nothing to update";
3610 break;
3611
3612 default:
3613 die("w00t");
3614 }
3615
3616 if (status && status->status == 'U') {
3617 text = "Press %s to resolve conflict in %s";
3618 key = get_key(REQ_STATUS_MERGE);
3619
3620 } else {
3621 key = get_key(REQ_STATUS_UPDATE);
3622 }
3623
3624 string_format(view->ref, text, key, file);
3625 }
3626
3627 static bool
3628 status_grep(struct view *view, struct line *line)
3629 {
3630 struct status *status = line->data;
3631 enum { S_STATUS, S_NAME, S_END } state;
3632 char buf[2] = "?";
3633 regmatch_t pmatch;
3634
3635 if (!status)
3636 return FALSE;
3637
3638 for (state = S_STATUS; state < S_END; state++) {
3639 char *text;
3640
3641 switch (state) {
3642 case S_NAME: text = status->name; break;
3643 case S_STATUS:
3644 buf[0] = status->status;
3645 text = buf;
3646 break;
3647
3648 default:
3649 return FALSE;
3650 }
3651
3652 if (regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
3653 return TRUE;
3654 }
3655
3656 return FALSE;
3657 }
3658
3659 static struct view_ops status_ops = {
3660 "file",
3661 status_open,
3662 NULL,
3663 status_draw,
3664 status_request,
3665 status_grep,
3666 status_select,
3667 };
3668
3669
3670 static bool
3671 stage_diff_line(FILE *pipe, struct line *line)
3672 {
3673 char *buf = line->data;
3674 size_t bufsize = strlen(buf);
3675 size_t written = 0;
3676
3677 while (!ferror(pipe) && written < bufsize) {
3678 written += fwrite(buf + written, 1, bufsize - written, pipe);
3679 }
3680
3681 fputc('\n', pipe);
3682
3683 return written == bufsize;
3684 }
3685
3686 static struct line *
3687 stage_diff_hdr(struct view *view, struct line *line)
3688 {
3689 int diff_hdr_dir = line->type == LINE_DIFF_CHUNK ? -1 : 1;
3690 struct line *diff_hdr;
3691
3692 if (line->type == LINE_DIFF_CHUNK)
3693 diff_hdr = line - 1;
3694 else
3695 diff_hdr = view->line + 1;
3696
3697 while (diff_hdr > view->line && diff_hdr < view->line + view->lines) {
3698 if (diff_hdr->type == LINE_DIFF_HEADER)
3699 return diff_hdr;
3700
3701 diff_hdr += diff_hdr_dir;
3702 }
3703
3704 return NULL;
3705 }
3706
3707 static bool
3708 stage_update_chunk(struct view *view, struct line *line)
3709 {
3710 char cmd[SIZEOF_STR];
3711 size_t cmdsize = 0;
3712 struct line *diff_hdr, *diff_chunk, *diff_end;
3713 FILE *pipe;
3714
3715 diff_hdr = stage_diff_hdr(view, line);
3716 if (!diff_hdr)
3717 return FALSE;
3718
3719 if (opt_cdup[0] &&
3720 !string_format_from(cmd, &cmdsize, "cd %s;", opt_cdup))
3721 return FALSE;
3722
3723 if (!string_format_from(cmd, &cmdsize,
3724 "git apply --cached %s - && "
3725 "git update-index -q --unmerged --refresh 2>/dev/null",
3726 stage_line_type == LINE_STAT_STAGED ? "-R" : ""))
3727 return FALSE;
3728
3729 pipe = popen(cmd, "w");
3730 if (!pipe)
3731 return FALSE;
3732
3733 diff_end = view->line + view->lines;
3734 if (line->type != LINE_DIFF_CHUNK) {
3735 diff_chunk = diff_hdr;
3736
3737 } else {
3738 for (diff_chunk = line + 1; diff_chunk < diff_end; diff_chunk++)
3739 if (diff_chunk->type == LINE_DIFF_CHUNK ||
3740 diff_chunk->type == LINE_DIFF_HEADER)
3741 diff_end = diff_chunk;
3742
3743 diff_chunk = line;
3744
3745 while (diff_hdr->type != LINE_DIFF_CHUNK) {
3746 switch (diff_hdr->type) {
3747 case LINE_DIFF_HEADER:
3748 case LINE_DIFF_INDEX:
3749 case LINE_DIFF_ADD:
3750 case LINE_DIFF_DEL:
3751 break;
3752
3753 default:
3754 diff_hdr++;
3755 continue;
3756 }
3757
3758 if (!stage_diff_line(pipe, diff_hdr++)) {
3759 pclose(pipe);
3760 return FALSE;
3761 }
3762 }
3763 }
3764
3765 while (diff_chunk < diff_end && stage_diff_line(pipe, diff_chunk))
3766 diff_chunk++;
3767
3768 pclose(pipe);
3769
3770 if (diff_chunk != diff_end)
3771 return FALSE;
3772
3773 return TRUE;
3774 }
3775
3776 static void
3777 stage_update(struct view *view, struct line *line)
3778 {
3779 if (stage_line_type != LINE_STAT_UNTRACKED &&
3780 (line->type == LINE_DIFF_CHUNK || !stage_status.status)) {
3781 if (!stage_update_chunk(view, line)) {
3782 report("Failed to apply chunk");
3783 return;
3784 }
3785
3786 } else if (!status_update_file(view, &stage_status, stage_line_type)) {
3787 report("Failed to update file");
3788 return;
3789 }
3790
3791 open_view(view, REQ_VIEW_STATUS, OPEN_RELOAD);
3792
3793 view = VIEW(REQ_VIEW_STATUS);
3794 if (view_is_displayed(view))
3795 status_enter(view, &view->line[view->lineno]);
3796 }
3797
3798 static enum request
3799 stage_request(struct view *view, enum request request, struct line *line)
3800 {
3801 switch (request) {
3802 case REQ_STATUS_UPDATE:
3803 stage_update(view, line);
3804 break;
3805
3806 case REQ_EDIT:
3807 if (!stage_status.name[0])
3808 return request;
3809
3810 open_editor(stage_status.status != '?', stage_status.name);
3811 break;
3812
3813 case REQ_ENTER:
3814 pager_request(view, request, line);
3815 break;
3816
3817 default:
3818 return request;
3819 }
3820
3821 return REQ_NONE;
3822 }
3823
3824 static struct view_ops stage_ops = {
3825 "line",
3826 NULL,
3827 pager_read,
3828 pager_draw,
3829 stage_request,
3830 pager_grep,
3831 pager_select,
3832 };
3833
3834
3835 /*
3836 * Revision graph
3837 */
3838
3839 struct commit {
3840 char id[SIZEOF_REV]; /* SHA1 ID. */
3841 char title[128]; /* First line of the commit message. */
3842 char author[75]; /* Author of the commit. */
3843 struct tm time; /* Date from the author ident. */
3844 struct ref **refs; /* Repository references. */
3845 chtype graph[SIZEOF_REVGRAPH]; /* Ancestry chain graphics. */
3846 size_t graph_size; /* The width of the graph array. */
3847 };
3848
3849 /* Size of rev graph with no "padding" columns */
3850 #define SIZEOF_REVITEMS (SIZEOF_REVGRAPH - (SIZEOF_REVGRAPH / 2))
3851
3852 struct rev_graph {
3853 struct rev_graph *prev, *next, *parents;
3854 char rev[SIZEOF_REVITEMS][SIZEOF_REV];
3855 size_t size;
3856 struct commit *commit;
3857 size_t pos;
3858 };
3859
3860 /* Parents of the commit being visualized. */
3861 static struct rev_graph graph_parents[4];
3862
3863 /* The current stack of revisions on the graph. */
3864 static struct rev_graph graph_stacks[4] = {
3865 { &graph_stacks[3], &graph_stacks[1], &graph_parents[0] },
3866 { &graph_stacks[0], &graph_stacks[2], &graph_parents[1] },
3867 { &graph_stacks[1], &graph_stacks[3], &graph_parents[2] },
3868 { &graph_stacks[2], &graph_stacks[0], &graph_parents[3] },
3869 };
3870
3871 static inline bool
3872 graph_parent_is_merge(struct rev_graph *graph)
3873 {
3874 return graph->parents->size > 1;
3875 }
3876
3877 static inline void
3878 append_to_rev_graph(struct rev_graph *graph, chtype symbol)
3879 {
3880 struct commit *commit = graph->commit;
3881
3882 if (commit->graph_size < ARRAY_SIZE(commit->graph) - 1)
3883 commit->graph[commit->graph_size++] = symbol;
3884 }
3885
3886 static void
3887 done_rev_graph(struct rev_graph *graph)
3888 {
3889 if (graph_parent_is_merge(graph) &&
3890 graph->pos < graph->size - 1 &&
3891 graph->next->size == graph->size + graph->parents->size - 1) {
3892 size_t i = graph->pos + graph->parents->size - 1;
3893
3894 graph->commit->graph_size = i * 2;
3895 while (i < graph->next->size - 1) {
3896 append_to_rev_graph(graph, ' ');
3897 append_to_rev_graph(graph, '\\');
3898 i++;
3899 }
3900 }
3901
3902 graph->size = graph->pos = 0;
3903 graph->commit = NULL;
3904 memset(graph->parents, 0, sizeof(*graph->parents));
3905 }
3906
3907 static void
3908 push_rev_graph(struct rev_graph *graph, char *parent)
3909 {
3910 int i;
3911
3912 /* "Collapse" duplicate parents lines.
3913 *
3914 * FIXME: This needs to also update update the drawn graph but
3915 * for now it just serves as a method for pruning graph lines. */
3916 for (i = 0; i < graph->size; i++)
3917 if (!strncmp(graph->rev[i], parent, SIZEOF_REV))
3918 return;
3919
3920 if (graph->size < SIZEOF_REVITEMS) {
3921 string_copy_rev(graph->rev[graph->size++], parent);
3922 }
3923 }
3924
3925 static chtype
3926 get_rev_graph_symbol(struct rev_graph *graph)
3927 {
3928 chtype symbol;
3929
3930 if (graph->parents->size == 0)
3931 symbol = REVGRAPH_INIT;
3932 else if (graph_parent_is_merge(graph))
3933 symbol = REVGRAPH_MERGE;
3934 else if (graph->pos >= graph->size)
3935 symbol = REVGRAPH_BRANCH;
3936 else
3937 symbol = REVGRAPH_COMMIT;
3938
3939 return symbol;
3940 }
3941
3942 static void
3943 draw_rev_graph(struct rev_graph *graph)
3944 {
3945 struct rev_filler {
3946 chtype separator, line;
3947 };
3948 enum { DEFAULT, RSHARP, RDIAG, LDIAG };
3949 static struct rev_filler fillers[] = {
3950 { ' ', REVGRAPH_LINE },
3951 { '`', '.' },
3952 { '\'', ' ' },
3953 { '/', ' ' },
3954 };
3955 chtype symbol = get_rev_graph_symbol(graph);
3956 struct rev_filler *filler;
3957 size_t i;
3958
3959 filler = &fillers[DEFAULT];
3960
3961 for (i = 0; i < graph->pos; i++) {
3962 append_to_rev_graph(graph, filler->line);
3963 if (graph_parent_is_merge(graph->prev) &&
3964 graph->prev->pos == i)
3965 filler = &fillers[RSHARP];
3966
3967 append_to_rev_graph(graph, filler->separator);
3968 }
3969
3970 /* Place the symbol for this revision. */
3971 append_to_rev_graph(graph, symbol);
3972
3973 if (graph->prev->size > graph->size)
3974 filler = &fillers[RDIAG];
3975 else
3976 filler = &fillers[DEFAULT];
3977
3978 i++;
3979
3980 for (; i < graph->size; i++) {
3981 append_to_rev_graph(graph, filler->separator);
3982 append_to_rev_graph(graph, filler->line);
3983 if (graph_parent_is_merge(graph->prev) &&
3984 i < graph->prev->pos + graph->parents->size)
3985 filler = &fillers[RSHARP];
3986 if (graph->prev->size > graph->size)
3987 filler = &fillers[LDIAG];
3988 }
3989
3990 if (graph->prev->size > graph->size) {
3991 append_to_rev_graph(graph, filler->separator);
3992 if (filler->line != ' ')
3993 append_to_rev_graph(graph, filler->line);
3994 }
3995 }
3996
3997 /* Prepare the next rev graph */
3998 static void
3999 prepare_rev_graph(struct rev_graph *graph)
4000 {
4001 size_t i;
4002
4003 /* First, traverse all lines of revisions up to the active one. */
4004 for (graph->pos = 0; graph->pos < graph->size; graph->pos++) {
4005 if (!strcmp(graph->rev[graph->pos], graph->commit->id))
4006 break;
4007
4008 push_rev_graph(graph->next, graph->rev[graph->pos]);
4009 }
4010
4011 /* Interleave the new revision parent(s). */
4012 for (i = 0; i < graph->parents->size; i++)
4013 push_rev_graph(graph->next, graph->parents->rev[i]);
4014
4015 /* Lastly, put any remaining revisions. */
4016 for (i = graph->pos + 1; i < graph->size; i++)
4017 push_rev_graph(graph->next, graph->rev[i]);
4018 }
4019
4020 static void
4021 update_rev_graph(struct rev_graph *graph)
4022 {
4023 /* If this is the finalizing update ... */
4024 if (graph->commit)
4025 prepare_rev_graph(graph);
4026
4027 /* Graph visualization needs a one rev look-ahead,
4028 * so the first update doesn't visualize anything. */
4029 if (!graph->prev->commit)
4030 return;
4031
4032 draw_rev_graph(graph->prev);
4033 done_rev_graph(graph->prev->prev);
4034 }
4035
4036
4037 /*
4038 * Main view backend
4039 */
4040
4041 static bool
4042 main_draw(struct view *view, struct line *line, unsigned int lineno, bool selected)
4043 {
4044 char buf[DATE_COLS + 1];
4045 struct commit *commit = line->data;
4046 enum line_type type;
4047 int col = 0;
4048 size_t timelen;
4049 size_t authorlen;
4050 int trimmed = 1;
4051
4052 if (!*commit->author)
4053 return FALSE;
4054
4055 wmove(view->win, lineno, col);
4056
4057 if (selected) {
4058 type = LINE_CURSOR;
4059 wattrset(view->win, get_line_attr(type));
4060 wchgat(view->win, -1, 0, type, NULL);
4061
4062 } else {
4063 type = LINE_MAIN_COMMIT;
4064 wattrset(view->win, get_line_attr(LINE_MAIN_DATE));
4065 }
4066
4067 timelen = strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time);
4068 waddnstr(view->win, buf, timelen);
4069 waddstr(view->win, " ");
4070
4071 col += DATE_COLS;
4072 wmove(view->win, lineno, col);
4073 if (type != LINE_CURSOR)
4074 wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
4075
4076 if (opt_utf8) {
4077 authorlen = utf8_length(commit->author, AUTHOR_COLS - 2, &col, &trimmed);
4078 } else {
4079 authorlen = strlen(commit->author);
4080 if (authorlen > AUTHOR_COLS - 2) {
4081 authorlen = AUTHOR_COLS - 2;
4082 trimmed = 1;
4083 }
4084 }
4085
4086 if (trimmed) {
4087 waddnstr(view->win, commit->author, authorlen);
4088 if (type != LINE_CURSOR)
4089 wattrset(view->win, get_line_attr(LINE_MAIN_DELIM));
4090 waddch(view->win, '~');
4091 } else {
4092 waddstr(view->win, commit->author);
4093 }
4094
4095 col += AUTHOR_COLS;
4096 if (type != LINE_CURSOR)
4097 wattrset(view->win, A_NORMAL);
4098
4099 if (opt_rev_graph && commit->graph_size) {
4100 size_t i;
4101
4102 wmove(view->win, lineno, col);
4103 /* Using waddch() instead of waddnstr() ensures that
4104 * they'll be rendered correctly for the cursor line. */
4105 for (i = 0; i < commit->graph_size; i++)
4106 waddch(view->win, commit->graph[i]);
4107
4108 waddch(view->win, ' ');
4109 col += commit->graph_size + 1;
4110 }
4111
4112 wmove(view->win, lineno, col);
4113
4114 if (commit->refs) {
4115 size_t i = 0;
4116
4117 do {
4118 if (type == LINE_CURSOR)
4119 ;
4120 else if (commit->refs[i]->tag)
4121 wattrset(view->win, get_line_attr(LINE_MAIN_TAG));
4122 else if (commit->refs[i]->remote)
4123 wattrset(view->win, get_line_attr(LINE_MAIN_REMOTE));
4124 else
4125 wattrset(view->win, get_line_attr(LINE_MAIN_REF));
4126 waddstr(view->win, "[");
4127 waddstr(view->win, commit->refs[i]->name);
4128 waddstr(view->win, "]");
4129 if (type != LINE_CURSOR)
4130 wattrset(view->win, A_NORMAL);
4131 waddstr(view->win, " ");
4132 col += strlen(commit->refs[i]->name) + STRING_SIZE("[] ");
4133 } while (commit->refs[i++]->next);
4134 }
4135
4136 if (type != LINE_CURSOR)
4137 wattrset(view->win, get_line_attr(type));
4138
4139 {
4140 int titlelen = strlen(commit->title);
4141
4142 if (col + titlelen > view->width)
4143 titlelen = view->width - col;
4144
4145 waddnstr(view->win, commit->title, titlelen);
4146 }
4147
4148 return TRUE;
4149 }
4150
4151 /* Reads git log --pretty=raw output and parses it into the commit struct. */
4152 static bool
4153 main_read(struct view *view, char *line)
4154 {
4155 static struct rev_graph *graph = graph_stacks;
4156 enum line_type type;
4157 struct commit *commit;
4158
4159 if (!line) {
4160 update_rev_graph(graph);
4161 return TRUE;
4162 }
4163
4164 type = get_line_type(line);
4165 if (type == LINE_COMMIT) {
4166 commit = calloc(1, sizeof(struct commit));
4167 if (!commit)
4168 return FALSE;
4169
4170 string_copy_rev(commit->id, line + STRING_SIZE("commit "));
4171 commit->refs = get_refs(commit->id);
4172 graph->commit = commit;
4173 add_line_data(view, commit, LINE_MAIN_COMMIT);
4174 return TRUE;
4175 }
4176
4177 if (!view->lines)
4178 return TRUE;
4179 commit = view->line[view->lines - 1].data;
4180
4181 switch (type) {
4182 case LINE_PARENT:
4183 push_rev_graph(graph->parents, line + STRING_SIZE("parent "));
4184 break;
4185
4186 case LINE_AUTHOR:
4187 {
4188 /* Parse author lines where the name may be empty:
4189 * author <email@address.tld> 1138474660 +0100
4190 */
4191 char *ident = line + STRING_SIZE("author ");
4192 char *nameend = strchr(ident, '<');
4193 char *emailend = strchr(ident, '>');
4194
4195 if (!nameend || !emailend)
4196 break;
4197
4198 update_rev_graph(graph);
4199 graph = graph->next;
4200
4201 *nameend = *emailend = 0;
4202 ident = chomp_string(ident);
4203 if (!*ident) {
4204 ident = chomp_string(nameend + 1);
4205 if (!*ident)
4206 ident = "Unknown";
4207 }
4208
4209 string_ncopy(commit->author, ident, strlen(ident));
4210
4211 /* Parse epoch and timezone */
4212 if (emailend[1] == ' ') {
4213 char *secs = emailend + 2;
4214 char *zone = strchr(secs, ' ');
4215 time_t time = (time_t) atol(secs);
4216
4217 if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
4218 long tz;
4219
4220 zone++;
4221 tz = ('0' - zone[1]) * 60 * 60 * 10;
4222 tz += ('0' - zone[2]) * 60 * 60;
4223 tz += ('0' - zone[3]) * 60;
4224 tz += ('0' - zone[4]) * 60;
4225
4226 if (zone[0] == '-')
4227 tz = -tz;
4228
4229 time -= tz;
4230 }
4231
4232 gmtime_r(&time, &commit->time);
4233 }
4234 break;
4235 }
4236 default:
4237 /* Fill in the commit title if it has not already been set. */
4238 if (commit->title[0])
4239 break;
4240
4241 /* Require titles to start with a non-space character at the
4242 * offset used by git log. */
4243 if (strncmp(line, " ", 4))
4244 break;
4245 line += 4;
4246 /* Well, if the title starts with a whitespace character,
4247 * try to be forgiving. Otherwise we end up with no title. */
4248 while (isspace(*line))
4249 line++;
4250 if (*line == '\0')
4251 break;
4252 /* FIXME: More graceful handling of titles; append "..." to
4253 * shortened titles, etc. */
4254
4255 string_ncopy(commit->title, line, strlen(line));
4256 }
4257
4258 return TRUE;
4259 }
4260
4261 static enum request
4262 main_request(struct view *view, enum request request, struct line *line)
4263 {
4264 enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
4265
4266 if (request == REQ_ENTER)
4267 open_view(view, REQ_VIEW_DIFF, flags);
4268 else
4269 return request;
4270
4271 return REQ_NONE;
4272 }
4273
4274 static bool
4275 main_grep(struct view *view, struct line *line)
4276 {
4277 struct commit *commit = line->data;
4278 enum { S_TITLE, S_AUTHOR, S_DATE, S_END } state;
4279 char buf[DATE_COLS + 1];
4280 regmatch_t pmatch;
4281
4282 for (state = S_TITLE; state < S_END; state++) {
4283 char *text;
4284
4285 switch (state) {
4286 case S_TITLE: text = commit->title; break;
4287 case S_AUTHOR: text = commit->author; break;
4288 case S_DATE:
4289 if (!strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time))
4290 continue;
4291 text = buf;
4292 break;
4293
4294 default:
4295 return FALSE;
4296 }
4297
4298 if (regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
4299 return TRUE;
4300 }
4301
4302 return FALSE;
4303 }
4304
4305 static void
4306 main_select(struct view *view, struct line *line)
4307 {
4308 struct commit *commit = line->data;
4309
4310 string_copy_rev(view->ref, commit->id);
4311 string_copy_rev(ref_commit, view->ref);
4312 }
4313
4314 static struct view_ops main_ops = {
4315 "commit",
4316 NULL,
4317 main_read,
4318 main_draw,
4319 main_request,
4320 main_grep,
4321 main_select,
4322 };
4323
4324
4325 /*
4326 * Unicode / UTF-8 handling
4327 *
4328 * NOTE: Much of the following code for dealing with unicode is derived from
4329 * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
4330 * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
4331 */
4332
4333 /* I've (over)annotated a lot of code snippets because I am not entirely
4334 * confident that the approach taken by this small UTF-8 interface is correct.
4335 * --jonas */
4336
4337 static inline int
4338 unicode_width(unsigned long c)
4339 {
4340 if (c >= 0x1100 &&
4341 (c <= 0x115f /* Hangul Jamo */
4342 || c == 0x2329
4343 || c == 0x232a
4344 || (c >= 0x2e80 && c <= 0xa4cf && c != 0x303f)
4345 /* CJK ... Yi */
4346 || (c >= 0xac00 && c <= 0xd7a3) /* Hangul Syllables */
4347 || (c >= 0xf900 && c <= 0xfaff) /* CJK Compatibility Ideographs */
4348 || (c >= 0xfe30 && c <= 0xfe6f) /* CJK Compatibility Forms */
4349 || (c >= 0xff00 && c <= 0xff60) /* Fullwidth Forms */
4350 || (c >= 0xffe0 && c <= 0xffe6)
4351 || (c >= 0x20000 && c <= 0x2fffd)
4352 || (c >= 0x30000 && c <= 0x3fffd)))
4353 return 2;
4354
4355 return 1;
4356 }
4357
4358 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
4359 * Illegal bytes are set one. */
4360 static const unsigned char utf8_bytes[256] = {
4361 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,
4362 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,
4363 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,
4364 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,
4365 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,
4366 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,
4367 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,
4368 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,
4369 };
4370
4371 /* Decode UTF-8 multi-byte representation into a unicode character. */
4372 static inline unsigned long
4373 utf8_to_unicode(const char *string, size_t length)
4374 {
4375 unsigned long unicode;
4376
4377 switch (length) {
4378 case 1:
4379 unicode = string[0];
4380 break;
4381 case 2:
4382 unicode = (string[0] & 0x1f) << 6;
4383 unicode += (string[1] & 0x3f);
4384 break;
4385 case 3:
4386 unicode = (string[0] & 0x0f) << 12;
4387 unicode += ((string[1] & 0x3f) << 6);
4388 unicode += (string[2] & 0x3f);
4389 break;
4390 case 4:
4391 unicode = (string[0] & 0x0f) << 18;
4392 unicode += ((string[1] & 0x3f) << 12);
4393 unicode += ((string[2] & 0x3f) << 6);
4394 unicode += (string[3] & 0x3f);
4395 break;
4396 case 5:
4397 unicode = (string[0] & 0x0f) << 24;
4398 unicode += ((string[1] & 0x3f) << 18);
4399 unicode += ((string[2] & 0x3f) << 12);
4400 unicode += ((string[3] & 0x3f) << 6);
4401 unicode += (string[4] & 0x3f);
4402 break;
4403 case 6:
4404 unicode = (string[0] & 0x01) << 30;
4405 unicode += ((string[1] & 0x3f) << 24);
4406 unicode += ((string[2] & 0x3f) << 18);
4407 unicode += ((string[3] & 0x3f) << 12);
4408 unicode += ((string[4] & 0x3f) << 6);
4409 unicode += (string[5] & 0x3f);
4410 break;
4411 default:
4412 die("Invalid unicode length");
4413 }
4414
4415 /* Invalid characters could return the special 0xfffd value but NUL
4416 * should be just as good. */
4417 return unicode > 0xffff ? 0 : unicode;
4418 }
4419
4420 /* Calculates how much of string can be shown within the given maximum width
4421 * and sets trimmed parameter to non-zero value if all of string could not be
4422 * shown.
4423 *
4424 * Additionally, adds to coloffset how many many columns to move to align with
4425 * the expected position. Takes into account how multi-byte and double-width
4426 * characters will effect the cursor position.
4427 *
4428 * Returns the number of bytes to output from string to satisfy max_width. */
4429 static size_t
4430 utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed)
4431 {
4432 const char *start = string;
4433 const char *end = strchr(string, '\0');
4434 size_t mbwidth = 0;
4435 size_t width = 0;
4436
4437 *trimmed = 0;
4438
4439 while (string < end) {
4440 int c = *(unsigned char *) string;
4441 unsigned char bytes = utf8_bytes[c];
4442 size_t ucwidth;
4443 unsigned long unicode;
4444
4445 if (string + bytes > end)
4446 break;
4447
4448 /* Change representation to figure out whether
4449 * it is a single- or double-width character. */
4450
4451 unicode = utf8_to_unicode(string, bytes);
4452 /* FIXME: Graceful handling of invalid unicode character. */
4453 if (!unicode)
4454 break;
4455
4456 ucwidth = unicode_width(unicode);
4457 width += ucwidth;
4458 if (width > max_width) {
4459 *trimmed = 1;
4460 break;
4461 }
4462
4463 /* The column offset collects the differences between the
4464 * number of bytes encoding a character and the number of
4465 * columns will be used for rendering said character.
4466 *
4467 * So if some character A is encoded in 2 bytes, but will be
4468 * represented on the screen using only 1 byte this will and up
4469 * adding 1 to the multi-byte column offset.
4470 *
4471 * Assumes that no double-width character can be encoding in
4472 * less than two bytes. */
4473 if (bytes > ucwidth)
4474 mbwidth += bytes - ucwidth;
4475
4476 string += bytes;
4477 }
4478
4479 *coloffset += mbwidth;
4480
4481 return string - start;
4482 }
4483
4484
4485 /*
4486 * Status management
4487 */
4488
4489 /* Whether or not the curses interface has been initialized. */
4490 static bool cursed = FALSE;
4491
4492 /* The status window is used for polling keystrokes. */
4493 static WINDOW *status_win;
4494
4495 static bool status_empty = TRUE;
4496
4497 /* Update status and title window. */
4498 static void
4499 report(const char *msg, ...)
4500 {
4501 struct view *view = display[current_view];
4502
4503 if (input_mode)
4504 return;
4505
4506 if (!view) {
4507 char buf[SIZEOF_STR];
4508 va_list args;
4509
4510 va_start(args, msg);
4511 if (vsnprintf(buf, sizeof(buf), msg, args) >= sizeof(buf)) {
4512 buf[sizeof(buf) - 1] = 0;
4513 buf[sizeof(buf) - 2] = '.';
4514 buf[sizeof(buf) - 3] = '.';
4515 buf[sizeof(buf) - 4] = '.';
4516 }
4517 va_end(args);
4518 die("%s", buf);
4519 }
4520
4521 if (!status_empty || *msg) {
4522 va_list args;
4523
4524 va_start(args, msg);
4525
4526 wmove(status_win, 0, 0);
4527 if (*msg) {
4528 vwprintw(status_win, msg, args);
4529 status_empty = FALSE;
4530 } else {
4531 status_empty = TRUE;
4532 }
4533 wclrtoeol(status_win);
4534 wrefresh(status_win);
4535
4536 va_end(args);
4537 }
4538
4539 update_view_title(view);
4540 update_display_cursor(view);
4541 }
4542
4543 /* Controls when nodelay should be in effect when polling user input. */
4544 static void
4545 set_nonblocking_input(bool loading)
4546 {
4547 static unsigned int loading_views;
4548
4549 if ((loading == FALSE && loading_views-- == 1) ||
4550 (loading == TRUE && loading_views++ == 0))
4551 nodelay(status_win, loading);
4552 }
4553
4554 static void
4555 init_display(void)
4556 {
4557 int x, y;
4558
4559 /* Initialize the curses library */
4560 if (isatty(STDIN_FILENO)) {
4561 cursed = !!initscr();
4562 } else {
4563 /* Leave stdin and stdout alone when acting as a pager. */
4564 FILE *io = fopen("/dev/tty", "r+");
4565
4566 if (!io)
4567 die("Failed to open /dev/tty");
4568 cursed = !!newterm(NULL, io, io);
4569 }
4570
4571 if (!cursed)
4572 die("Failed to initialize curses");
4573
4574 nonl(); /* Tell curses not to do NL->CR/NL on output */
4575 cbreak(); /* Take input chars one at a time, no wait for \n */
4576 noecho(); /* Don't echo input */
4577 leaveok(stdscr, TRUE);
4578
4579 if (has_colors())
4580 init_colors();
4581
4582 getmaxyx(stdscr, y, x);
4583 status_win = newwin(1, 0, y - 1, 0);
4584 if (!status_win)
4585 die("Failed to create status window");
4586
4587 /* Enable keyboard mapping */
4588 keypad(status_win, TRUE);
4589 wbkgdset(status_win, get_line_attr(LINE_STATUS));
4590 }
4591
4592 static char *
4593 read_prompt(const char *prompt)
4594 {
4595 enum { READING, STOP, CANCEL } status = READING;
4596 static char buf[sizeof(opt_cmd) - STRING_SIZE("git \0")];
4597 int pos = 0;
4598
4599 while (status == READING) {
4600 struct view *view;
4601 int i, key;
4602
4603 input_mode = TRUE;
4604
4605 foreach_view (view, i)
4606 update_view(view);
4607
4608 input_mode = FALSE;
4609
4610 mvwprintw(status_win, 0, 0, "%s%.*s", prompt, pos, buf);
4611 wclrtoeol(status_win);
4612
4613 /* Refresh, accept single keystroke of input */
4614 key = wgetch(status_win);
4615 switch (key) {
4616 case KEY_RETURN:
4617 case KEY_ENTER:
4618 case '\n':
4619 status = pos ? STOP : CANCEL;
4620 break;
4621
4622 case KEY_BACKSPACE:
4623 if (pos > 0)
4624 pos--;
4625 else
4626 status = CANCEL;
4627 break;
4628
4629 case KEY_ESC:
4630 status = CANCEL;
4631 break;
4632
4633 case ERR:
4634 break;
4635
4636 default:
4637 if (pos >= sizeof(buf)) {
4638 report("Input string too long");
4639 return NULL;
4640 }
4641
4642 if (isprint(key))
4643 buf[pos++] = (char) key;
4644 }
4645 }
4646
4647 /* Clear the status window */
4648 status_empty = FALSE;
4649 report("");
4650
4651 if (status == CANCEL)
4652 return NULL;
4653
4654 buf[pos++] = 0;
4655
4656 return buf;
4657 }
4658
4659 /*
4660 * Repository references
4661 */
4662
4663 static struct ref *refs;
4664 static size_t refs_size;
4665
4666 /* Id <-> ref store */
4667 static struct ref ***id_refs;
4668 static size_t id_refs_size;
4669
4670 static struct ref **
4671 get_refs(char *id)
4672 {
4673 struct ref ***tmp_id_refs;
4674 struct ref **ref_list = NULL;
4675 size_t ref_list_size = 0;
4676 size_t i;
4677
4678 for (i = 0; i < id_refs_size; i++)
4679 if (!strcmp(id, id_refs[i][0]->id))
4680 return id_refs[i];
4681
4682 tmp_id_refs = realloc(id_refs, (id_refs_size + 1) * sizeof(*id_refs));
4683 if (!tmp_id_refs)
4684 return NULL;
4685
4686 id_refs = tmp_id_refs;
4687
4688 for (i = 0; i < refs_size; i++) {
4689 struct ref **tmp;
4690
4691 if (strcmp(id, refs[i].id))
4692 continue;
4693
4694 tmp = realloc(ref_list, (ref_list_size + 1) * sizeof(*ref_list));
4695 if (!tmp) {
4696 if (ref_list)
4697 free(ref_list);
4698 return NULL;
4699 }
4700
4701 ref_list = tmp;
4702 if (ref_list_size > 0)
4703 ref_list[ref_list_size - 1]->next = 1;
4704 ref_list[ref_list_size] = &refs[i];
4705
4706 /* XXX: The properties of the commit chains ensures that we can
4707 * safely modify the shared ref. The repo references will
4708 * always be similar for the same id. */
4709 ref_list[ref_list_size]->next = 0;
4710 ref_list_size++;
4711 }
4712
4713 if (ref_list)
4714 id_refs[id_refs_size++] = ref_list;
4715
4716 return ref_list;
4717 }
4718
4719 static int
4720 read_ref(char *id, size_t idlen, char *name, size_t namelen)
4721 {
4722 struct ref *ref;
4723 bool tag = FALSE;
4724 bool remote = FALSE;
4725
4726 if (!strncmp(name, "refs/tags/", STRING_SIZE("refs/tags/"))) {
4727 /* Commits referenced by tags has "^{}" appended. */
4728 if (name[namelen - 1] != '}')
4729 return OK;
4730
4731 while (namelen > 0 && name[namelen] != '^')
4732 namelen--;
4733
4734 tag = TRUE;
4735 namelen -= STRING_SIZE("refs/tags/");
4736 name += STRING_SIZE("refs/tags/");
4737
4738 } else if (!strncmp(name, "refs/remotes/", STRING_SIZE("refs/remotes/"))) {
4739 remote = TRUE;
4740 namelen -= STRING_SIZE("refs/remotes/");
4741 name += STRING_SIZE("refs/remotes/");
4742
4743 } else if (!strncmp(name, "refs/heads/", STRING_SIZE("refs/heads/"))) {
4744 namelen -= STRING_SIZE("refs/heads/");
4745 name += STRING_SIZE("refs/heads/");
4746
4747 } else if (!strcmp(name, "HEAD")) {
4748 return OK;
4749 }
4750
4751 refs = realloc(refs, sizeof(*refs) * (refs_size + 1));
4752 if (!refs)
4753 return ERR;
4754
4755 ref = &refs[refs_size++];
4756 ref->name = malloc(namelen + 1);
4757 if (!ref->name)
4758 return ERR;
4759
4760 strncpy(ref->name, name, namelen);
4761 ref->name[namelen] = 0;
4762 ref->tag = tag;
4763 ref->remote = remote;
4764 string_copy_rev(ref->id, id);
4765
4766 return OK;
4767 }
4768
4769 static int
4770 load_refs(void)
4771 {
4772 const char *cmd_env = getenv("TIG_LS_REMOTE");
4773 const char *cmd = cmd_env && *cmd_env ? cmd_env : TIG_LS_REMOTE;
4774
4775 return read_properties(popen(cmd, "r"), "\t", read_ref);
4776 }
4777
4778 static int
4779 read_repo_config_option(char *name, size_t namelen, char *value, size_t valuelen)
4780 {
4781 if (!strcmp(name, "i18n.commitencoding"))
4782 string_ncopy(opt_encoding, value, valuelen);
4783
4784 if (!strcmp(name, "core.editor"))
4785 string_ncopy(opt_editor, value, valuelen);
4786
4787 return OK;
4788 }
4789
4790 static int
4791 load_repo_config(void)
4792 {
4793 return read_properties(popen(GIT_CONFIG " --list", "r"),
4794 "=", read_repo_config_option);
4795 }
4796
4797 static int
4798 read_repo_info(char *name, size_t namelen, char *value, size_t valuelen)
4799 {
4800 if (!opt_git_dir[0]) {
4801 string_ncopy(opt_git_dir, name, namelen);
4802
4803 } else if (opt_is_inside_work_tree == -1) {
4804 /* This can be 3 different values depending on the
4805 * version of git being used. If git-rev-parse does not
4806 * understand --is-inside-work-tree it will simply echo
4807 * the option else either "true" or "false" is printed.
4808 * Default to true for the unknown case. */
4809 opt_is_inside_work_tree = strcmp(name, "false") ? TRUE : FALSE;
4810
4811 } else {
4812 string_ncopy(opt_cdup, name, namelen);
4813 }
4814
4815 return OK;
4816 }
4817
4818 /* XXX: The line outputted by "--show-cdup" can be empty so the option
4819 * must be the last one! */
4820 static int
4821 load_repo_info(void)
4822 {
4823 return read_properties(popen("git rev-parse --git-dir --is-inside-work-tree --show-cdup 2>/dev/null", "r"),
4824 "=", read_repo_info);
4825 }
4826
4827 static int
4828 read_properties(FILE *pipe, const char *separators,
4829 int (*read_property)(char *, size_t, char *, size_t))
4830 {
4831 char buffer[BUFSIZ];
4832 char *name;
4833 int state = OK;
4834
4835 if (!pipe)
4836 return ERR;
4837
4838 while (state == OK && (name = fgets(buffer, sizeof(buffer), pipe))) {
4839 char *value;
4840 size_t namelen;
4841 size_t valuelen;
4842
4843 name = chomp_string(name);
4844 namelen = strcspn(name, separators);
4845
4846 if (name[namelen]) {
4847 name[namelen] = 0;
4848 value = chomp_string(name + namelen + 1);
4849 valuelen = strlen(value);
4850
4851 } else {
4852 value = "";
4853 valuelen = 0;
4854 }
4855
4856 state = read_property(name, namelen, value, valuelen);
4857 }
4858
4859 if (state != ERR && ferror(pipe))
4860 state = ERR;
4861
4862 pclose(pipe);
4863
4864 return state;
4865 }
4866
4867
4868 /*
4869 * Main
4870 */
4871
4872 static void __NORETURN
4873 quit(int sig)
4874 {
4875 /* XXX: Restore tty modes and let the OS cleanup the rest! */
4876 if (cursed)
4877 endwin();
4878 exit(0);
4879 }
4880
4881 static void __NORETURN
4882 die(const char *err, ...)
4883 {
4884 va_list args;
4885
4886 endwin();
4887
4888 va_start(args, err);
4889 fputs("tig: ", stderr);
4890 vfprintf(stderr, err, args);
4891 fputs("\n", stderr);
4892 va_end(args);
4893
4894 exit(1);
4895 }
4896
4897 int
4898 main(int argc, char *argv[])
4899 {
4900 struct view *view;
4901 enum request request;
4902 size_t i;
4903
4904 signal(SIGINT, quit);
4905
4906 if (setlocale(LC_ALL, "")) {
4907 char *codeset = nl_langinfo(CODESET);
4908
4909 string_ncopy(opt_codeset, codeset, strlen(codeset));
4910 }
4911
4912 if (load_repo_info() == ERR)
4913 die("Failed to load repo info.");
4914
4915 if (load_options() == ERR)
4916 die("Failed to load user config.");
4917
4918 /* Load the repo config file so options can be overwritten from
4919 * the command line. */
4920 if (load_repo_config() == ERR)
4921 die("Failed to load repo config.");
4922
4923 if (!parse_options(argc, argv))
4924 return 0;
4925
4926 /* Require a git repository unless when running in pager mode. */
4927 if (!opt_git_dir[0])
4928 die("Not a git repository");
4929
4930 if (*opt_codeset && strcmp(opt_codeset, opt_encoding)) {
4931 opt_iconv = iconv_open(opt_codeset, opt_encoding);
4932 if (opt_iconv == ICONV_NONE)
4933 die("Failed to initialize character set conversion");
4934 }
4935
4936 if (load_refs() == ERR)
4937 die("Failed to load refs.");
4938
4939 for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
4940 view->cmd_env = getenv(view->cmd_env);
4941
4942 request = opt_request;
4943
4944 init_display();
4945
4946 while (view_driver(display[current_view], request)) {
4947 int key;
4948 int i;
4949
4950 foreach_view (view, i)
4951 update_view(view);
4952
4953 /* Refresh, accept single keystroke of input */
4954 key = wgetch(status_win);
4955
4956 /* wgetch() with nodelay() enabled returns ERR when there's no
4957 * input. */
4958 if (key == ERR) {
4959 request = REQ_NONE;
4960 continue;
4961 }
4962
4963 request = get_keybinding(display[current_view]->keymap, key);
4964
4965 /* Some low-level request handling. This keeps access to
4966 * status_win restricted. */
4967 switch (request) {
4968 case REQ_PROMPT:
4969 {
4970 char *cmd = read_prompt(":");
4971
4972 if (cmd && string_format(opt_cmd, "git %s", cmd)) {
4973 if (strncmp(cmd, "show", 4) && isspace(cmd[4])) {
4974 opt_request = REQ_VIEW_DIFF;
4975 } else {
4976 opt_request = REQ_VIEW_PAGER;
4977 }
4978 break;
4979 }
4980
4981 request = REQ_NONE;
4982 break;
4983 }
4984 case REQ_SEARCH:
4985 case REQ_SEARCH_BACK:
4986 {
4987 const char *prompt = request == REQ_SEARCH
4988 ? "/" : "?";
4989 char *search = read_prompt(prompt);
4990
4991 if (search)
4992 string_ncopy(opt_search, search, strlen(search));
4993 else
4994 request = REQ_NONE;
4995 break;
4996 }
4997 case REQ_SCREEN_RESIZE:
4998 {
4999 int height, width;
5000
5001 getmaxyx(stdscr, height, width);
5002
5003 /* Resize the status view and let the view driver take
5004 * care of resizing the displayed views. */
5005 wresize(status_win, 1, width);
5006 mvwin(status_win, height - 1, 0);
5007 wrefresh(status_win);
5008 break;
5009 }
5010 default:
5011 break;
5012 }
5013 }
5014
5015 quit(0);
5016
5017 return 0;
5018 }
Full-screen terminal Git browser.