~mdw / tig / blob
? search:


48eeb4dfaf2dba766b9d66c40946ed867b99d203
[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 value += valuelen;
1223
1224 /* Nothing more to tokenize or last available token. */
1225 if (!*value || argc >= ARRAY_SIZE(argv))
1226 break;
1227
1228 *value++ = 0;
1229 while (isspace(*value))
1230 value++;
1231 }
1232
1233 if (!strcmp(opt, "color"))
1234 return option_color_command(argc, argv);
1235
1236 if (!strcmp(opt, "set"))
1237 return option_set_command(argc, argv);
1238
1239 if (!strcmp(opt, "bind"))
1240 return option_bind_command(argc, argv);
1241
1242 config_msg = "Unknown option command";
1243 return ERR;
1244 }
1245
1246 static int
1247 read_option(char *opt, size_t optlen, char *value, size_t valuelen)
1248 {
1249 int status = OK;
1250
1251 config_lineno++;
1252 config_msg = "Internal error";
1253
1254 /* Check for comment markers, since read_properties() will
1255 * only ensure opt and value are split at first " \t". */
1256 optlen = strcspn(opt, "#");
1257 if (optlen == 0)
1258 return OK;
1259
1260 if (opt[optlen] != 0) {
1261 config_msg = "No option value";
1262 status = ERR;
1263
1264 } else {
1265 /* Look for comment endings in the value. */
1266 size_t len = strcspn(value, "#");
1267
1268 if (len < valuelen) {
1269 valuelen = len;
1270 value[valuelen] = 0;
1271 }
1272
1273 status = set_option(opt, value);
1274 }
1275
1276 if (status == ERR) {
1277 fprintf(stderr, "Error on line %d, near '%.*s': %s\n",
1278 config_lineno, (int) optlen, opt, config_msg);
1279 config_errors = TRUE;
1280 }
1281
1282 /* Always keep going if errors are encountered. */
1283 return OK;
1284 }
1285
1286 static int
1287 load_options(void)
1288 {
1289 char *home = getenv("HOME");
1290 char buf[SIZEOF_STR];
1291 FILE *file;
1292
1293 config_lineno = 0;
1294 config_errors = FALSE;
1295
1296 add_builtin_run_requests();
1297
1298 if (!home || !string_format(buf, "%s/.tigrc", home))
1299 return ERR;
1300
1301 /* It's ok that the file doesn't exist. */
1302 file = fopen(buf, "r");
1303 if (!file)
1304 return OK;
1305
1306 if (read_properties(file, " \t", read_option) == ERR ||
1307 config_errors == TRUE)
1308 fprintf(stderr, "Errors while loading %s.\n", buf);
1309
1310 return OK;
1311 }
1312
1313
1314 /*
1315 * The viewer
1316 */
1317
1318 struct view;
1319 struct view_ops;
1320
1321 /* The display array of active views and the index of the current view. */
1322 static struct view *display[2];
1323 static unsigned int current_view;
1324
1325 /* Reading from the prompt? */
1326 static bool input_mode = FALSE;
1327
1328 #define foreach_displayed_view(view, i) \
1329 for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
1330
1331 #define displayed_views() (display[1] != NULL ? 2 : 1)
1332
1333 /* Current head and commit ID */
1334 static char ref_blob[SIZEOF_REF] = "";
1335 static char ref_commit[SIZEOF_REF] = "HEAD";
1336 static char ref_head[SIZEOF_REF] = "HEAD";
1337
1338 struct view {
1339 const char *name; /* View name */
1340 const char *cmd_fmt; /* Default command line format */
1341 const char *cmd_env; /* Command line set via environment */
1342 const char *id; /* Points to either of ref_{head,commit,blob} */
1343
1344 struct view_ops *ops; /* View operations */
1345
1346 enum keymap keymap; /* What keymap does this view have */
1347
1348 char cmd[SIZEOF_STR]; /* Command buffer */
1349 char ref[SIZEOF_REF]; /* Hovered commit reference */
1350 char vid[SIZEOF_REF]; /* View ID. Set to id member when updating. */
1351
1352 int height, width; /* The width and height of the main window */
1353 WINDOW *win; /* The main window */
1354 WINDOW *title; /* The title window living below the main window */
1355
1356 /* Navigation */
1357 unsigned long offset; /* Offset of the window top */
1358 unsigned long lineno; /* Current line number */
1359
1360 /* Searching */
1361 char grep[SIZEOF_STR]; /* Search string */
1362 regex_t *regex; /* Pre-compiled regex */
1363
1364 /* If non-NULL, points to the view that opened this view. If this view
1365 * is closed tig will switch back to the parent view. */
1366 struct view *parent;
1367
1368 /* Buffering */
1369 unsigned long lines; /* Total number of lines */
1370 struct line *line; /* Line index */
1371 unsigned long line_size;/* Total number of allocated lines */
1372 unsigned int digits; /* Number of digits in the lines member. */
1373
1374 /* Loading */
1375 FILE *pipe;
1376 time_t start_time;
1377 };
1378
1379 struct view_ops {
1380 /* What type of content being displayed. Used in the title bar. */
1381 const char *type;
1382 /* Open and reads in all view content. */
1383 bool (*open)(struct view *view);
1384 /* Read one line; updates view->line. */
1385 bool (*read)(struct view *view, char *data);
1386 /* Draw one line; @lineno must be < view->height. */
1387 bool (*draw)(struct view *view, struct line *line, unsigned int lineno, bool selected);
1388 /* Depending on view handle a special requests. */
1389 enum request (*request)(struct view *view, enum request request, struct line *line);
1390 /* Search for regex in a line. */
1391 bool (*grep)(struct view *view, struct line *line);
1392 /* Select line */
1393 void (*select)(struct view *view, struct line *line);
1394 };
1395
1396 static struct view_ops pager_ops;
1397 static struct view_ops main_ops;
1398 static struct view_ops tree_ops;
1399 static struct view_ops blob_ops;
1400 static struct view_ops help_ops;
1401 static struct view_ops status_ops;
1402 static struct view_ops stage_ops;
1403
1404 #define VIEW_STR(name, cmd, env, ref, ops, map) \
1405 { name, cmd, #env, ref, ops, map}
1406
1407 #define VIEW_(id, name, ops, ref) \
1408 VIEW_STR(name, TIG_##id##_CMD, TIG_##id##_CMD, ref, ops, KEYMAP_##id)
1409
1410
1411 static struct view views[] = {
1412 VIEW_(MAIN, "main", &main_ops, ref_head),
1413 VIEW_(DIFF, "diff", &pager_ops, ref_commit),
1414 VIEW_(LOG, "log", &pager_ops, ref_head),
1415 VIEW_(TREE, "tree", &tree_ops, ref_commit),
1416 VIEW_(BLOB, "blob", &blob_ops, ref_blob),
1417 VIEW_(HELP, "help", &help_ops, ""),
1418 VIEW_(PAGER, "pager", &pager_ops, "stdin"),
1419 VIEW_(STATUS, "status", &status_ops, ""),
1420 VIEW_(STAGE, "stage", &stage_ops, ""),
1421 };
1422
1423 #define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
1424
1425 #define foreach_view(view, i) \
1426 for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
1427
1428 #define view_is_displayed(view) \
1429 (view == display[0] || view == display[1])
1430
1431 static bool
1432 draw_view_line(struct view *view, unsigned int lineno)
1433 {
1434 struct line *line;
1435 bool selected = (view->offset + lineno == view->lineno);
1436 bool draw_ok;
1437
1438 assert(view_is_displayed(view));
1439
1440 if (view->offset + lineno >= view->lines)
1441 return FALSE;
1442
1443 line = &view->line[view->offset + lineno];
1444
1445 if (selected) {
1446 line->selected = TRUE;
1447 view->ops->select(view, line);
1448 } else if (line->selected) {
1449 line->selected = FALSE;
1450 wmove(view->win, lineno, 0);
1451 wclrtoeol(view->win);
1452 }
1453
1454 scrollok(view->win, FALSE);
1455 draw_ok = view->ops->draw(view, line, lineno, selected);
1456 scrollok(view->win, TRUE);
1457
1458 return draw_ok;
1459 }
1460
1461 static void
1462 redraw_view_from(struct view *view, int lineno)
1463 {
1464 assert(0 <= lineno && lineno < view->height);
1465
1466 for (; lineno < view->height; lineno++) {
1467 if (!draw_view_line(view, lineno))
1468 break;
1469 }
1470
1471 redrawwin(view->win);
1472 if (input_mode)
1473 wnoutrefresh(view->win);
1474 else
1475 wrefresh(view->win);
1476 }
1477
1478 static void
1479 redraw_view(struct view *view)
1480 {
1481 wclear(view->win);
1482 redraw_view_from(view, 0);
1483 }
1484
1485
1486 static void
1487 update_view_title(struct view *view)
1488 {
1489 char buf[SIZEOF_STR];
1490 char state[SIZEOF_STR];
1491 size_t bufpos = 0, statelen = 0;
1492
1493 assert(view_is_displayed(view));
1494
1495 if (view != VIEW(REQ_VIEW_STATUS) && (view->lines || view->pipe)) {
1496 unsigned int view_lines = view->offset + view->height;
1497 unsigned int lines = view->lines
1498 ? MIN(view_lines, view->lines) * 100 / view->lines
1499 : 0;
1500
1501 string_format_from(state, &statelen, "- %s %d of %d (%d%%)",
1502 view->ops->type,
1503 view->lineno + 1,
1504 view->lines,
1505 lines);
1506
1507 if (view->pipe) {
1508 time_t secs = time(NULL) - view->start_time;
1509
1510 /* Three git seconds are a long time ... */
1511 if (secs > 2)
1512 string_format_from(state, &statelen, " %lds", secs);
1513 }
1514 }
1515
1516 string_format_from(buf, &bufpos, "[%s]", view->name);
1517 if (*view->ref && bufpos < view->width) {
1518 size_t refsize = strlen(view->ref);
1519 size_t minsize = bufpos + 1 + /* abbrev= */ 7 + 1 + statelen;
1520
1521 if (minsize < view->width)
1522 refsize = view->width - minsize + 7;
1523 string_format_from(buf, &bufpos, " %.*s", (int) refsize, view->ref);
1524 }
1525
1526 if (statelen && bufpos < view->width) {
1527 string_format_from(buf, &bufpos, " %s", state);
1528 }
1529
1530 if (view == display[current_view])
1531 wbkgdset(view->title, get_line_attr(LINE_TITLE_FOCUS));
1532 else
1533 wbkgdset(view->title, get_line_attr(LINE_TITLE_BLUR));
1534
1535 mvwaddnstr(view->title, 0, 0, buf, bufpos);
1536 wclrtoeol(view->title);
1537 wmove(view->title, 0, view->width - 1);
1538
1539 if (input_mode)
1540 wnoutrefresh(view->title);
1541 else
1542 wrefresh(view->title);
1543 }
1544
1545 static void
1546 resize_display(void)
1547 {
1548 int offset, i;
1549 struct view *base = display[0];
1550 struct view *view = display[1] ? display[1] : display[0];
1551
1552 /* Setup window dimensions */
1553
1554 getmaxyx(stdscr, base->height, base->width);
1555
1556 /* Make room for the status window. */
1557 base->height -= 1;
1558
1559 if (view != base) {
1560 /* Horizontal split. */
1561 view->width = base->width;
1562 view->height = SCALE_SPLIT_VIEW(base->height);
1563 base->height -= view->height;
1564
1565 /* Make room for the title bar. */
1566 view->height -= 1;
1567 }
1568
1569 /* Make room for the title bar. */
1570 base->height -= 1;
1571
1572 offset = 0;
1573
1574 foreach_displayed_view (view, i) {
1575 if (!view->win) {
1576 view->win = newwin(view->height, 0, offset, 0);
1577 if (!view->win)
1578 die("Failed to create %s view", view->name);
1579
1580 scrollok(view->win, TRUE);
1581
1582 view->title = newwin(1, 0, offset + view->height, 0);
1583 if (!view->title)
1584 die("Failed to create title window");
1585
1586 } else {
1587 wresize(view->win, view->height, view->width);
1588 mvwin(view->win, offset, 0);
1589 mvwin(view->title, offset + view->height, 0);
1590 }
1591
1592 offset += view->height + 1;
1593 }
1594 }
1595
1596 static void
1597 redraw_display(void)
1598 {
1599 struct view *view;
1600 int i;
1601
1602 foreach_displayed_view (view, i) {
1603 redraw_view(view);
1604 update_view_title(view);
1605 }
1606 }
1607
1608 static void
1609 update_display_cursor(struct view *view)
1610 {
1611 /* Move the cursor to the right-most column of the cursor line.
1612 *
1613 * XXX: This could turn out to be a bit expensive, but it ensures that
1614 * the cursor does not jump around. */
1615 if (view->lines) {
1616 wmove(view->win, view->lineno - view->offset, view->width - 1);
1617 wrefresh(view->win);
1618 }
1619 }
1620
1621 /*
1622 * Navigation
1623 */
1624
1625 /* Scrolling backend */
1626 static void
1627 do_scroll_view(struct view *view, int lines)
1628 {
1629 bool redraw_current_line = FALSE;
1630
1631 /* The rendering expects the new offset. */
1632 view->offset += lines;
1633
1634 assert(0 <= view->offset && view->offset < view->lines);
1635 assert(lines);
1636
1637 /* Move current line into the view. */
1638 if (view->lineno < view->offset) {
1639 view->lineno = view->offset;
1640 redraw_current_line = TRUE;
1641 } else if (view->lineno >= view->offset + view->height) {
1642 view->lineno = view->offset + view->height - 1;
1643 redraw_current_line = TRUE;
1644 }
1645
1646 assert(view->offset <= view->lineno && view->lineno < view->lines);
1647
1648 /* Redraw the whole screen if scrolling is pointless. */
1649 if (view->height < ABS(lines)) {
1650 redraw_view(view);
1651
1652 } else {
1653 int line = lines > 0 ? view->height - lines : 0;
1654 int end = line + ABS(lines);
1655
1656 wscrl(view->win, lines);
1657
1658 for (; line < end; line++) {
1659 if (!draw_view_line(view, line))
1660 break;
1661 }
1662
1663 if (redraw_current_line)
1664 draw_view_line(view, view->lineno - view->offset);
1665 }
1666
1667 redrawwin(view->win);
1668 wrefresh(view->win);
1669 report("");
1670 }
1671
1672 /* Scroll frontend */
1673 static void
1674 scroll_view(struct view *view, enum request request)
1675 {
1676 int lines = 1;
1677
1678 assert(view_is_displayed(view));
1679
1680 switch (request) {
1681 case REQ_SCROLL_PAGE_DOWN:
1682 lines = view->height;
1683 case REQ_SCROLL_LINE_DOWN:
1684 if (view->offset + lines > view->lines)
1685 lines = view->lines - view->offset;
1686
1687 if (lines == 0 || view->offset + view->height >= view->lines) {
1688 report("Cannot scroll beyond the last line");
1689 return;
1690 }
1691 break;
1692
1693 case REQ_SCROLL_PAGE_UP:
1694 lines = view->height;
1695 case REQ_SCROLL_LINE_UP:
1696 if (lines > view->offset)
1697 lines = view->offset;
1698
1699 if (lines == 0) {
1700 report("Cannot scroll beyond the first line");
1701 return;
1702 }
1703
1704 lines = -lines;
1705 break;
1706
1707 default:
1708 die("request %d not handled in switch", request);
1709 }
1710
1711 do_scroll_view(view, lines);
1712 }
1713
1714 /* Cursor moving */
1715 static void
1716 move_view(struct view *view, enum request request)
1717 {
1718 int scroll_steps = 0;
1719 int steps;
1720
1721 switch (request) {
1722 case REQ_MOVE_FIRST_LINE:
1723 steps = -view->lineno;
1724 break;
1725
1726 case REQ_MOVE_LAST_LINE:
1727 steps = view->lines - view->lineno - 1;
1728 break;
1729
1730 case REQ_MOVE_PAGE_UP:
1731 steps = view->height > view->lineno
1732 ? -view->lineno : -view->height;
1733 break;
1734
1735 case REQ_MOVE_PAGE_DOWN:
1736 steps = view->lineno + view->height >= view->lines
1737 ? view->lines - view->lineno - 1 : view->height;
1738 break;
1739
1740 case REQ_MOVE_UP:
1741 steps = -1;
1742 break;
1743
1744 case REQ_MOVE_DOWN:
1745 steps = 1;
1746 break;
1747
1748 default:
1749 die("request %d not handled in switch", request);
1750 }
1751
1752 if (steps <= 0 && view->lineno == 0) {
1753 report("Cannot move beyond the first line");
1754 return;
1755
1756 } else if (steps >= 0 && view->lineno + 1 >= view->lines) {
1757 report("Cannot move beyond the last line");
1758 return;
1759 }
1760
1761 /* Move the current line */
1762 view->lineno += steps;
1763 assert(0 <= view->lineno && view->lineno < view->lines);
1764
1765 /* Check whether the view needs to be scrolled */
1766 if (view->lineno < view->offset ||
1767 view->lineno >= view->offset + view->height) {
1768 scroll_steps = steps;
1769 if (steps < 0 && -steps > view->offset) {
1770 scroll_steps = -view->offset;
1771
1772 } else if (steps > 0) {
1773 if (view->lineno == view->lines - 1 &&
1774 view->lines > view->height) {
1775 scroll_steps = view->lines - view->offset - 1;
1776 if (scroll_steps >= view->height)
1777 scroll_steps -= view->height - 1;
1778 }
1779 }
1780 }
1781
1782 if (!view_is_displayed(view)) {
1783 view->offset += scroll_steps;
1784 assert(0 <= view->offset && view->offset < view->lines);
1785 view->ops->select(view, &view->line[view->lineno]);
1786 return;
1787 }
1788
1789 /* Repaint the old "current" line if we be scrolling */
1790 if (ABS(steps) < view->height)
1791 draw_view_line(view, view->lineno - steps - view->offset);
1792
1793 if (scroll_steps) {
1794 do_scroll_view(view, scroll_steps);
1795 return;
1796 }
1797
1798 /* Draw the current line */
1799 draw_view_line(view, view->lineno - view->offset);
1800
1801 redrawwin(view->win);
1802 wrefresh(view->win);
1803 report("");
1804 }
1805
1806
1807 /*
1808 * Searching
1809 */
1810
1811 static void search_view(struct view *view, enum request request);
1812
1813 static bool
1814 find_next_line(struct view *view, unsigned long lineno, struct line *line)
1815 {
1816 assert(view_is_displayed(view));
1817
1818 if (!view->ops->grep(view, line))
1819 return FALSE;
1820
1821 if (lineno - view->offset >= view->height) {
1822 view->offset = lineno;
1823 view->lineno = lineno;
1824 redraw_view(view);
1825
1826 } else {
1827 unsigned long old_lineno = view->lineno - view->offset;
1828
1829 view->lineno = lineno;
1830 draw_view_line(view, old_lineno);
1831
1832 draw_view_line(view, view->lineno - view->offset);
1833 redrawwin(view->win);
1834 wrefresh(view->win);
1835 }
1836
1837 report("Line %ld matches '%s'", lineno + 1, view->grep);
1838 return TRUE;
1839 }
1840
1841 static void
1842 find_next(struct view *view, enum request request)
1843 {
1844 unsigned long lineno = view->lineno;
1845 int direction;
1846
1847 if (!*view->grep) {
1848 if (!*opt_search)
1849 report("No previous search");
1850 else
1851 search_view(view, request);
1852 return;
1853 }
1854
1855 switch (request) {
1856 case REQ_SEARCH:
1857 case REQ_FIND_NEXT:
1858 direction = 1;
1859 break;
1860
1861 case REQ_SEARCH_BACK:
1862 case REQ_FIND_PREV:
1863 direction = -1;
1864 break;
1865
1866 default:
1867 return;
1868 }
1869
1870 if (request == REQ_FIND_NEXT || request == REQ_FIND_PREV)
1871 lineno += direction;
1872
1873 /* Note, lineno is unsigned long so will wrap around in which case it
1874 * will become bigger than view->lines. */
1875 for (; lineno < view->lines; lineno += direction) {
1876 struct line *line = &view->line[lineno];
1877
1878 if (find_next_line(view, lineno, line))
1879 return;
1880 }
1881
1882 report("No match found for '%s'", view->grep);
1883 }
1884
1885 static void
1886 search_view(struct view *view, enum request request)
1887 {
1888 int regex_err;
1889
1890 if (view->regex) {
1891 regfree(view->regex);
1892 *view->grep = 0;
1893 } else {
1894 view->regex = calloc(1, sizeof(*view->regex));
1895 if (!view->regex)
1896 return;
1897 }
1898
1899 regex_err = regcomp(view->regex, opt_search, REG_EXTENDED);
1900 if (regex_err != 0) {
1901 char buf[SIZEOF_STR] = "unknown error";
1902
1903 regerror(regex_err, view->regex, buf, sizeof(buf));
1904 report("Search failed: %s", buf);
1905 return;
1906 }
1907
1908 string_copy(view->grep, opt_search);
1909
1910 find_next(view, request);
1911 }
1912
1913 /*
1914 * Incremental updating
1915 */
1916
1917 static void
1918 end_update(struct view *view)
1919 {
1920 if (!view->pipe)
1921 return;
1922 set_nonblocking_input(FALSE);
1923 if (view->pipe == stdin)
1924 fclose(view->pipe);
1925 else
1926 pclose(view->pipe);
1927 view->pipe = NULL;
1928 }
1929
1930 static bool
1931 begin_update(struct view *view)
1932 {
1933 if (view->pipe)
1934 end_update(view);
1935
1936 if (opt_cmd[0]) {
1937 string_copy(view->cmd, opt_cmd);
1938 opt_cmd[0] = 0;
1939 /* When running random commands, initially show the
1940 * command in the title. However, it maybe later be
1941 * overwritten if a commit line is selected. */
1942 if (view == VIEW(REQ_VIEW_PAGER))
1943 string_copy(view->ref, view->cmd);
1944 else
1945 view->ref[0] = 0;
1946
1947 } else if (view == VIEW(REQ_VIEW_TREE)) {
1948 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
1949 char path[SIZEOF_STR];
1950
1951 if (strcmp(view->vid, view->id))
1952 opt_path[0] = path[0] = 0;
1953 else if (sq_quote(path, 0, opt_path) >= sizeof(path))
1954 return FALSE;
1955
1956 if (!string_format(view->cmd, format, view->id, path))
1957 return FALSE;
1958
1959 } else {
1960 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
1961 const char *id = view->id;
1962
1963 if (!string_format(view->cmd, format, id, id, id, id, id))
1964 return FALSE;
1965
1966 /* Put the current ref_* value to the view title ref
1967 * member. This is needed by the blob view. Most other
1968 * views sets it automatically after loading because the
1969 * first line is a commit line. */
1970 string_copy_rev(view->ref, view->id);
1971 }
1972
1973 /* Special case for the pager view. */
1974 if (opt_pipe) {
1975 view->pipe = opt_pipe;
1976 opt_pipe = NULL;
1977 } else {
1978 view->pipe = popen(view->cmd, "r");
1979 }
1980
1981 if (!view->pipe)
1982 return FALSE;
1983
1984 set_nonblocking_input(TRUE);
1985
1986 view->offset = 0;
1987 view->lines = 0;
1988 view->lineno = 0;
1989 string_copy_rev(view->vid, view->id);
1990
1991 if (view->line) {
1992 int i;
1993
1994 for (i = 0; i < view->lines; i++)
1995 if (view->line[i].data)
1996 free(view->line[i].data);
1997
1998 free(view->line);
1999 view->line = NULL;
2000 }
2001
2002 view->start_time = time(NULL);
2003
2004 return TRUE;
2005 }
2006
2007 static struct line *
2008 realloc_lines(struct view *view, size_t line_size)
2009 {
2010 struct line *tmp = realloc(view->line, sizeof(*view->line) * line_size);
2011
2012 if (!tmp)
2013 return NULL;
2014
2015 view->line = tmp;
2016 view->line_size = line_size;
2017 return view->line;
2018 }
2019
2020 static bool
2021 update_view(struct view *view)
2022 {
2023 char in_buffer[BUFSIZ];
2024 char out_buffer[BUFSIZ * 2];
2025 char *line;
2026 /* The number of lines to read. If too low it will cause too much
2027 * redrawing (and possible flickering), if too high responsiveness
2028 * will suffer. */
2029 unsigned long lines = view->height;
2030 int redraw_from = -1;
2031
2032 if (!view->pipe)
2033 return TRUE;
2034
2035 /* Only redraw if lines are visible. */
2036 if (view->offset + view->height >= view->lines)
2037 redraw_from = view->lines - view->offset;
2038
2039 /* FIXME: This is probably not perfect for backgrounded views. */
2040 if (!realloc_lines(view, view->lines + lines))
2041 goto alloc_error;
2042
2043 while ((line = fgets(in_buffer, sizeof(in_buffer), view->pipe))) {
2044 size_t linelen = strlen(line);
2045
2046 if (linelen)
2047 line[linelen - 1] = 0;
2048
2049 if (opt_iconv != ICONV_NONE) {
2050 ICONV_CONST char *inbuf = line;
2051 size_t inlen = linelen;
2052
2053 char *outbuf = out_buffer;
2054 size_t outlen = sizeof(out_buffer);
2055
2056 size_t ret;
2057
2058 ret = iconv(opt_iconv, &inbuf, &inlen, &outbuf, &outlen);
2059 if (ret != (size_t) -1) {
2060 line = out_buffer;
2061 linelen = strlen(out_buffer);
2062 }
2063 }
2064
2065 if (!view->ops->read(view, line))
2066 goto alloc_error;
2067
2068 if (lines-- == 1)
2069 break;
2070 }
2071
2072 {
2073 int digits;
2074
2075 lines = view->lines;
2076 for (digits = 0; lines; digits++)
2077 lines /= 10;
2078
2079 /* Keep the displayed view in sync with line number scaling. */
2080 if (digits != view->digits) {
2081 view->digits = digits;
2082 redraw_from = 0;
2083 }
2084 }
2085
2086 if (!view_is_displayed(view))
2087 goto check_pipe;
2088
2089 if (view == VIEW(REQ_VIEW_TREE)) {
2090 /* Clear the view and redraw everything since the tree sorting
2091 * might have rearranged things. */
2092 redraw_view(view);
2093
2094 } else if (redraw_from >= 0) {
2095 /* If this is an incremental update, redraw the previous line
2096 * since for commits some members could have changed when
2097 * loading the main view. */
2098 if (redraw_from > 0)
2099 redraw_from--;
2100
2101 /* Since revision graph visualization requires knowledge
2102 * about the parent commit, it causes a further one-off
2103 * needed to be redrawn for incremental updates. */
2104 if (redraw_from > 0 && opt_rev_graph)
2105 redraw_from--;
2106
2107 /* Incrementally draw avoids flickering. */
2108 redraw_view_from(view, redraw_from);
2109 }
2110
2111 /* Update the title _after_ the redraw so that if the redraw picks up a
2112 * commit reference in view->ref it'll be available here. */
2113 update_view_title(view);
2114
2115 check_pipe:
2116 if (ferror(view->pipe)) {
2117 report("Failed to read: %s", strerror(errno));
2118 goto end;
2119
2120 } else if (feof(view->pipe)) {
2121 report("");
2122 goto end;
2123 }
2124
2125 return TRUE;
2126
2127 alloc_error:
2128 report("Allocation failure");
2129
2130 end:
2131 view->ops->read(view, NULL);
2132 end_update(view);
2133 return FALSE;
2134 }
2135
2136 static struct line *
2137 add_line_data(struct view *view, void *data, enum line_type type)
2138 {
2139 struct line *line = &view->line[view->lines++];
2140
2141 memset(line, 0, sizeof(*line));
2142 line->type = type;
2143 line->data = data;
2144
2145 return line;
2146 }
2147
2148 static struct line *
2149 add_line_text(struct view *view, char *data, enum line_type type)
2150 {
2151 if (data)
2152 data = strdup(data);
2153
2154 return data ? add_line_data(view, data, type) : NULL;
2155 }
2156
2157
2158 /*
2159 * View opening
2160 */
2161
2162 enum open_flags {
2163 OPEN_DEFAULT = 0, /* Use default view switching. */
2164 OPEN_SPLIT = 1, /* Split current view. */
2165 OPEN_BACKGROUNDED = 2, /* Backgrounded. */
2166 OPEN_RELOAD = 4, /* Reload view even if it is the current. */
2167 };
2168
2169 static void
2170 open_view(struct view *prev, enum request request, enum open_flags flags)
2171 {
2172 bool backgrounded = !!(flags & OPEN_BACKGROUNDED);
2173 bool split = !!(flags & OPEN_SPLIT);
2174 bool reload = !!(flags & OPEN_RELOAD);
2175 struct view *view = VIEW(request);
2176 int nviews = displayed_views();
2177 struct view *base_view = display[0];
2178
2179 if (view == prev && nviews == 1 && !reload) {
2180 report("Already in %s view", view->name);
2181 return;
2182 }
2183
2184 if (view->ops->open) {
2185 if (!view->ops->open(view)) {
2186 report("Failed to load %s view", view->name);
2187 return;
2188 }
2189
2190 } else if ((reload || strcmp(view->vid, view->id)) &&
2191 !begin_update(view)) {
2192 report("Failed to load %s view", view->name);
2193 return;
2194 }
2195
2196 if (split) {
2197 display[1] = view;
2198 if (!backgrounded)
2199 current_view = 1;
2200 } else {
2201 /* Maximize the current view. */
2202 memset(display, 0, sizeof(display));
2203 current_view = 0;
2204 display[current_view] = view;
2205 }
2206
2207 /* Resize the view when switching between split- and full-screen,
2208 * or when switching between two different full-screen views. */
2209 if (nviews != displayed_views() ||
2210 (nviews == 1 && base_view != display[0]))
2211 resize_display();
2212
2213 if (split && prev->lineno - prev->offset >= prev->height) {
2214 /* Take the title line into account. */
2215 int lines = prev->lineno - prev->offset - prev->height + 1;
2216
2217 /* Scroll the view that was split if the current line is
2218 * outside the new limited view. */
2219 do_scroll_view(prev, lines);
2220 }
2221
2222 if (prev && view != prev) {
2223 if (split && !backgrounded) {
2224 /* "Blur" the previous view. */
2225 update_view_title(prev);
2226 }
2227
2228 view->parent = prev;
2229 }
2230
2231 if (view->pipe && view->lines == 0) {
2232 /* Clear the old view and let the incremental updating refill
2233 * the screen. */
2234 wclear(view->win);
2235 report("");
2236 } else {
2237 redraw_view(view);
2238 report("");
2239 }
2240
2241 /* If the view is backgrounded the above calls to report()
2242 * won't redraw the view title. */
2243 if (backgrounded)
2244 update_view_title(view);
2245 }
2246
2247 static void
2248 open_external_viewer(const char *cmd)
2249 {
2250 def_prog_mode(); /* save current tty modes */
2251 endwin(); /* restore original tty modes */
2252 system(cmd);
2253 fprintf(stderr, "Press Enter to continue");
2254 getc(stdin);
2255 reset_prog_mode();
2256 redraw_display();
2257 }
2258
2259 static void
2260 open_mergetool(const char *file)
2261 {
2262 char cmd[SIZEOF_STR];
2263 char file_sq[SIZEOF_STR];
2264
2265 if (sq_quote(file_sq, 0, file) < sizeof(file_sq) &&
2266 string_format(cmd, "git mergetool %s", file_sq)) {
2267 open_external_viewer(cmd);
2268 }
2269 }
2270
2271 static void
2272 open_editor(bool from_root, const char *file)
2273 {
2274 char cmd[SIZEOF_STR];
2275 char file_sq[SIZEOF_STR];
2276 char *editor;
2277 char *prefix = from_root ? opt_cdup : "";
2278
2279 editor = getenv("GIT_EDITOR");
2280 if (!editor && *opt_editor)
2281 editor = opt_editor;
2282 if (!editor)
2283 editor = getenv("VISUAL");
2284 if (!editor)
2285 editor = getenv("EDITOR");
2286 if (!editor)
2287 editor = "vi";
2288
2289 if (sq_quote(file_sq, 0, file) < sizeof(file_sq) &&
2290 string_format(cmd, "%s %s%s", editor, prefix, file_sq)) {
2291 open_external_viewer(cmd);
2292 }
2293 }
2294
2295 static void
2296 open_run_request(enum request request)
2297 {
2298 struct run_request *req = get_run_request(request);
2299 char buf[SIZEOF_STR * 2];
2300 size_t bufpos;
2301 char *cmd;
2302
2303 if (!req) {
2304 report("Unknown run request");
2305 return;
2306 }
2307
2308 bufpos = 0;
2309 cmd = req->cmd;
2310
2311 while (cmd) {
2312 char *next = strstr(cmd, "%(");
2313 int len = next - cmd;
2314 char *value;
2315
2316 if (!next) {
2317 len = strlen(cmd);
2318 value = "";
2319
2320 } else if (!strncmp(next, "%(head)", 7)) {
2321 value = ref_head;
2322
2323 } else if (!strncmp(next, "%(commit)", 9)) {
2324 value = ref_commit;
2325
2326 } else if (!strncmp(next, "%(blob)", 7)) {
2327 value = ref_blob;
2328
2329 } else {
2330 report("Unknown replacement in run request: `%s`", req->cmd);
2331 return;
2332 }
2333
2334 if (!string_format_from(buf, &bufpos, "%.*s%s", len, cmd, value))
2335 return;
2336
2337 if (next)
2338 next = strchr(next, ')') + 1;
2339 cmd = next;
2340 }
2341
2342 open_external_viewer(buf);
2343 }
2344
2345 /*
2346 * User request switch noodle
2347 */
2348
2349 static int
2350 view_driver(struct view *view, enum request request)
2351 {
2352 int i;
2353
2354 if (request == REQ_NONE) {
2355 doupdate();
2356 return TRUE;
2357 }
2358
2359 if (request > REQ_NONE) {
2360 open_run_request(request);
2361 return TRUE;
2362 }
2363
2364 if (view && view->lines) {
2365 request = view->ops->request(view, request, &view->line[view->lineno]);
2366 if (request == REQ_NONE)
2367 return TRUE;
2368 }
2369
2370 switch (request) {
2371 case REQ_MOVE_UP:
2372 case REQ_MOVE_DOWN:
2373 case REQ_MOVE_PAGE_UP:
2374 case REQ_MOVE_PAGE_DOWN:
2375 case REQ_MOVE_FIRST_LINE:
2376 case REQ_MOVE_LAST_LINE:
2377 move_view(view, request);
2378 break;
2379
2380 case REQ_SCROLL_LINE_DOWN:
2381 case REQ_SCROLL_LINE_UP:
2382 case REQ_SCROLL_PAGE_DOWN:
2383 case REQ_SCROLL_PAGE_UP:
2384 scroll_view(view, request);
2385 break;
2386
2387 case REQ_VIEW_BLOB:
2388 if (!ref_blob[0]) {
2389 report("No file chosen, press %s to open tree view",
2390 get_key(REQ_VIEW_TREE));
2391 break;
2392 }
2393 open_view(view, request, OPEN_DEFAULT);
2394 break;
2395
2396 case REQ_VIEW_PAGER:
2397 if (!opt_pipe && !VIEW(REQ_VIEW_PAGER)->lines) {
2398 report("No pager content, press %s to run command from prompt",
2399 get_key(REQ_PROMPT));
2400 break;
2401 }
2402 open_view(view, request, OPEN_DEFAULT);
2403 break;
2404
2405 case REQ_VIEW_STAGE:
2406 if (!VIEW(REQ_VIEW_STAGE)->lines) {
2407 report("No stage content, press %s to open the status view and choose file",
2408 get_key(REQ_VIEW_STATUS));
2409 break;
2410 }
2411 open_view(view, request, OPEN_DEFAULT);
2412 break;
2413
2414 case REQ_VIEW_STATUS:
2415 if (opt_is_inside_work_tree == FALSE) {
2416 report("The status view requires a working tree");
2417 break;
2418 }
2419 open_view(view, request, OPEN_DEFAULT);
2420 break;
2421
2422 case REQ_VIEW_MAIN:
2423 case REQ_VIEW_DIFF:
2424 case REQ_VIEW_LOG:
2425 case REQ_VIEW_TREE:
2426 case REQ_VIEW_HELP:
2427 open_view(view, request, OPEN_DEFAULT);
2428 break;
2429
2430 case REQ_NEXT:
2431 case REQ_PREVIOUS:
2432 request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
2433
2434 if ((view == VIEW(REQ_VIEW_DIFF) &&
2435 view->parent == VIEW(REQ_VIEW_MAIN)) ||
2436 (view == VIEW(REQ_VIEW_STAGE) &&
2437 view->parent == VIEW(REQ_VIEW_STATUS)) ||
2438 (view == VIEW(REQ_VIEW_BLOB) &&
2439 view->parent == VIEW(REQ_VIEW_TREE))) {
2440 int line;
2441
2442 view = view->parent;
2443 line = view->lineno;
2444 move_view(view, request);
2445 if (view_is_displayed(view))
2446 update_view_title(view);
2447 if (line != view->lineno)
2448 view->ops->request(view, REQ_ENTER,
2449 &view->line[view->lineno]);
2450
2451 } else {
2452 move_view(view, request);
2453 }
2454 break;
2455
2456 case REQ_VIEW_NEXT:
2457 {
2458 int nviews = displayed_views();
2459 int next_view = (current_view + 1) % nviews;
2460
2461 if (next_view == current_view) {
2462 report("Only one view is displayed");
2463 break;
2464 }
2465
2466 current_view = next_view;
2467 /* Blur out the title of the previous view. */
2468 update_view_title(view);
2469 report("");
2470 break;
2471 }
2472 case REQ_REFRESH:
2473 report("Refreshing is not yet supported for the %s view", view->name);
2474 break;
2475
2476 case REQ_TOGGLE_LINENO:
2477 opt_line_number = !opt_line_number;
2478 redraw_display();
2479 break;
2480
2481 case REQ_TOGGLE_REV_GRAPH:
2482 opt_rev_graph = !opt_rev_graph;
2483 redraw_display();
2484 break;
2485
2486 case REQ_PROMPT:
2487 /* Always reload^Wrerun commands from the prompt. */
2488 open_view(view, opt_request, OPEN_RELOAD);
2489 break;
2490
2491 case REQ_SEARCH:
2492 case REQ_SEARCH_BACK:
2493 search_view(view, request);
2494 break;
2495
2496 case REQ_FIND_NEXT:
2497 case REQ_FIND_PREV:
2498 find_next(view, request);
2499 break;
2500
2501 case REQ_STOP_LOADING:
2502 for (i = 0; i < ARRAY_SIZE(views); i++) {
2503 view = &views[i];
2504 if (view->pipe)
2505 report("Stopped loading the %s view", view->name),
2506 end_update(view);
2507 }
2508 break;
2509
2510 case REQ_SHOW_VERSION:
2511 report("tig-%s (built %s)", TIG_VERSION, __DATE__);
2512 return TRUE;
2513
2514 case REQ_SCREEN_RESIZE:
2515 resize_display();
2516 /* Fall-through */
2517 case REQ_SCREEN_REDRAW:
2518 redraw_display();
2519 break;
2520
2521 case REQ_EDIT:
2522 report("Nothing to edit");
2523 break;
2524
2525
2526 case REQ_ENTER:
2527 report("Nothing to enter");
2528 break;
2529
2530
2531 case REQ_VIEW_CLOSE:
2532 /* XXX: Mark closed views by letting view->parent point to the
2533 * view itself. Parents to closed view should never be
2534 * followed. */
2535 if (view->parent &&
2536 view->parent->parent != view->parent) {
2537 memset(display, 0, sizeof(display));
2538 current_view = 0;
2539 display[current_view] = view->parent;
2540 view->parent = view;
2541 resize_display();
2542 redraw_display();
2543 break;
2544 }
2545 /* Fall-through */
2546 case REQ_QUIT:
2547 return FALSE;
2548
2549 default:
2550 /* An unknown key will show most commonly used commands. */
2551 report("Unknown key, press 'h' for help");
2552 return TRUE;
2553 }
2554
2555 return TRUE;
2556 }
2557
2558
2559 /*
2560 * Pager backend
2561 */
2562
2563 static bool
2564 pager_draw(struct view *view, struct line *line, unsigned int lineno, bool selected)
2565 {
2566 char *text = line->data;
2567 enum line_type type = line->type;
2568 int textlen = strlen(text);
2569 int attr;
2570
2571 wmove(view->win, lineno, 0);
2572
2573 if (selected) {
2574 type = LINE_CURSOR;
2575 wchgat(view->win, -1, 0, type, NULL);
2576 }
2577
2578 attr = get_line_attr(type);
2579 wattrset(view->win, attr);
2580
2581 if (opt_line_number || opt_tab_size < TABSIZE) {
2582 static char spaces[] = " ";
2583 int col_offset = 0, col = 0;
2584
2585 if (opt_line_number) {
2586 unsigned long real_lineno = view->offset + lineno + 1;
2587
2588 if (real_lineno == 1 ||
2589 (real_lineno % opt_num_interval) == 0) {
2590 wprintw(view->win, "%.*d", view->digits, real_lineno);
2591
2592 } else {
2593 waddnstr(view->win, spaces,
2594 MIN(view->digits, STRING_SIZE(spaces)));
2595 }
2596 waddstr(view->win, ": ");
2597 col_offset = view->digits + 2;
2598 }
2599
2600 while (text && col_offset + col < view->width) {
2601 int cols_max = view->width - col_offset - col;
2602 char *pos = text;
2603 int cols;
2604
2605 if (*text == '\t') {
2606 text++;
2607 assert(sizeof(spaces) > TABSIZE);
2608 pos = spaces;
2609 cols = opt_tab_size - (col % opt_tab_size);
2610
2611 } else {
2612 text = strchr(text, '\t');
2613 cols = line ? text - pos : strlen(pos);
2614 }
2615
2616 waddnstr(view->win, pos, MIN(cols, cols_max));
2617 col += cols;
2618 }
2619
2620 } else {
2621 int col = 0, pos = 0;
2622
2623 for (; pos < textlen && col < view->width; pos++, col++)
2624 if (text[pos] == '\t')
2625 col += TABSIZE - (col % TABSIZE) - 1;
2626
2627 waddnstr(view->win, text, pos);
2628 }
2629
2630 return TRUE;
2631 }
2632
2633 static bool
2634 add_describe_ref(char *buf, size_t *bufpos, char *commit_id, const char *sep)
2635 {
2636 char refbuf[SIZEOF_STR];
2637 char *ref = NULL;
2638 FILE *pipe;
2639
2640 if (!string_format(refbuf, "git describe %s 2>/dev/null", commit_id))
2641 return TRUE;
2642
2643 pipe = popen(refbuf, "r");
2644 if (!pipe)
2645 return TRUE;
2646
2647 if ((ref = fgets(refbuf, sizeof(refbuf), pipe)))
2648 ref = chomp_string(ref);
2649 pclose(pipe);
2650
2651 if (!ref || !*ref)
2652 return TRUE;
2653
2654 /* This is the only fatal call, since it can "corrupt" the buffer. */
2655 if (!string_nformat(buf, SIZEOF_STR, bufpos, "%s%s", sep, ref))
2656 return FALSE;
2657
2658 return TRUE;
2659 }
2660
2661 static void
2662 add_pager_refs(struct view *view, struct line *line)
2663 {
2664 char buf[SIZEOF_STR];
2665 char *commit_id = line->data + STRING_SIZE("commit ");
2666 struct ref **refs;
2667 size_t bufpos = 0, refpos = 0;
2668 const char *sep = "Refs: ";
2669 bool is_tag = FALSE;
2670
2671 assert(line->type == LINE_COMMIT);
2672
2673 refs = get_refs(commit_id);
2674 if (!refs) {
2675 if (view == VIEW(REQ_VIEW_DIFF))
2676 goto try_add_describe_ref;
2677 return;
2678 }
2679
2680 do {
2681 struct ref *ref = refs[refpos];
2682 char *fmt = ref->tag ? "%s[%s]" :
2683 ref->remote ? "%s<%s>" : "%s%s";
2684
2685 if (!string_format_from(buf, &bufpos, fmt, sep, ref->name))
2686 return;
2687 sep = ", ";
2688 if (ref->tag)
2689 is_tag = TRUE;
2690 } while (refs[refpos++]->next);
2691
2692 if (!is_tag && view == VIEW(REQ_VIEW_DIFF)) {
2693 try_add_describe_ref:
2694 /* Add <tag>-g<commit_id> "fake" reference. */
2695 if (!add_describe_ref(buf, &bufpos, commit_id, sep))
2696 return;
2697 }
2698
2699 if (bufpos == 0)
2700 return;
2701
2702 if (!realloc_lines(view, view->line_size + 1))
2703 return;
2704
2705 add_line_text(view, buf, LINE_PP_REFS);
2706 }
2707
2708 static bool
2709 pager_read(struct view *view, char *data)
2710 {
2711 struct line *line;
2712
2713 if (!data)
2714 return TRUE;
2715
2716 line = add_line_text(view, data, get_line_type(data));
2717 if (!line)
2718 return FALSE;
2719
2720 if (line->type == LINE_COMMIT &&
2721 (view == VIEW(REQ_VIEW_DIFF) ||
2722 view == VIEW(REQ_VIEW_LOG)))
2723 add_pager_refs(view, line);
2724
2725 return TRUE;
2726 }
2727
2728 static enum request
2729 pager_request(struct view *view, enum request request, struct line *line)
2730 {
2731 int split = 0;
2732
2733 if (request != REQ_ENTER)
2734 return request;
2735
2736 if (line->type == LINE_COMMIT &&
2737 (view == VIEW(REQ_VIEW_LOG) ||
2738 view == VIEW(REQ_VIEW_PAGER))) {
2739 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
2740 split = 1;
2741 }
2742
2743 /* Always scroll the view even if it was split. That way
2744 * you can use Enter to scroll through the log view and
2745 * split open each commit diff. */
2746 scroll_view(view, REQ_SCROLL_LINE_DOWN);
2747
2748 /* FIXME: A minor workaround. Scrolling the view will call report("")
2749 * but if we are scrolling a non-current view this won't properly
2750 * update the view title. */
2751 if (split)
2752 update_view_title(view);
2753
2754 return REQ_NONE;
2755 }
2756
2757 static bool
2758 pager_grep(struct view *view, struct line *line)
2759 {
2760 regmatch_t pmatch;
2761 char *text = line->data;
2762
2763 if (!*text)
2764 return FALSE;
2765
2766 if (regexec(view->regex, text, 1, &pmatch, 0) == REG_NOMATCH)
2767 return FALSE;
2768
2769 return TRUE;
2770 }
2771
2772 static void
2773 pager_select(struct view *view, struct line *line)
2774 {
2775 if (line->type == LINE_COMMIT) {
2776 char *text = line->data + STRING_SIZE("commit ");
2777
2778 if (view != VIEW(REQ_VIEW_PAGER))
2779 string_copy_rev(view->ref, text);
2780 string_copy_rev(ref_commit, text);
2781 }
2782 }
2783
2784 static struct view_ops pager_ops = {
2785 "line",
2786 NULL,
2787 pager_read,
2788 pager_draw,
2789 pager_request,
2790 pager_grep,
2791 pager_select,
2792 };
2793
2794
2795 /*
2796 * Help backend
2797 */
2798
2799 static bool
2800 help_open(struct view *view)
2801 {
2802 char buf[BUFSIZ];
2803 int lines = ARRAY_SIZE(req_info) + 2;
2804 int i;
2805
2806 if (view->lines > 0)
2807 return TRUE;
2808
2809 for (i = 0; i < ARRAY_SIZE(req_info); i++)
2810 if (!req_info[i].request)
2811 lines++;
2812
2813 lines += run_requests + 1;
2814
2815 view->line = calloc(lines, sizeof(*view->line));
2816 if (!view->line)
2817 return FALSE;
2818
2819 add_line_text(view, "Quick reference for tig keybindings:", LINE_DEFAULT);
2820
2821 for (i = 0; i < ARRAY_SIZE(req_info); i++) {
2822 char *key;
2823
2824 if (req_info[i].request == REQ_NONE)
2825 continue;
2826
2827 if (!req_info[i].request) {
2828 add_line_text(view, "", LINE_DEFAULT);
2829 add_line_text(view, req_info[i].help, LINE_DEFAULT);
2830 continue;
2831 }
2832
2833 key = get_key(req_info[i].request);
2834 if (!*key)
2835 key = "(no key defined)";
2836
2837 if (!string_format(buf, " %-25s %s", key, req_info[i].help))
2838 continue;
2839
2840 add_line_text(view, buf, LINE_DEFAULT);
2841 }
2842
2843 if (run_requests) {
2844 add_line_text(view, "", LINE_DEFAULT);
2845 add_line_text(view, "External commands:", LINE_DEFAULT);
2846 }
2847
2848 for (i = 0; i < run_requests; i++) {
2849 struct run_request *req = get_run_request(REQ_NONE + i + 1);
2850 char *key;
2851
2852 if (!req)
2853 continue;
2854
2855 key = get_key_name(req->key);
2856 if (!*key)
2857 key = "(no key defined)";
2858
2859 if (!string_format(buf, " %-10s %-14s `%s`",
2860 keymap_table[req->keymap].name,
2861 key, req->cmd))
2862 continue;
2863
2864 add_line_text(view, buf, LINE_DEFAULT);
2865 }
2866
2867 return TRUE;
2868 }
2869
2870 static struct view_ops help_ops = {
2871 "line",
2872 help_open,
2873 NULL,
2874 pager_draw,
2875 pager_request,
2876 pager_grep,
2877 pager_select,
2878 };
2879
2880
2881 /*
2882 * Tree backend
2883 */
2884
2885 struct tree_stack_entry {
2886 struct tree_stack_entry *prev; /* Entry below this in the stack */
2887 unsigned long lineno; /* Line number to restore */
2888 char *name; /* Position of name in opt_path */
2889 };
2890
2891 /* The top of the path stack. */
2892 static struct tree_stack_entry *tree_stack = NULL;
2893 unsigned long tree_lineno = 0;
2894
2895 static void
2896 pop_tree_stack_entry(void)
2897 {
2898 struct tree_stack_entry *entry = tree_stack;
2899
2900 tree_lineno = entry->lineno;
2901 entry->name[0] = 0;
2902 tree_stack = entry->prev;
2903 free(entry);
2904 }
2905
2906 static void
2907 push_tree_stack_entry(char *name, unsigned long lineno)
2908 {
2909 struct tree_stack_entry *entry = calloc(1, sizeof(*entry));
2910 size_t pathlen = strlen(opt_path);
2911
2912 if (!entry)
2913 return;
2914
2915 entry->prev = tree_stack;
2916 entry->name = opt_path + pathlen;
2917 tree_stack = entry;
2918
2919 if (!string_format_from(opt_path, &pathlen, "%s/", name)) {
2920 pop_tree_stack_entry();
2921 return;
2922 }
2923
2924 /* Move the current line to the first tree entry. */
2925 tree_lineno = 1;
2926 entry->lineno = lineno;
2927 }
2928
2929 /* Parse output from git-ls-tree(1):
2930 *
2931 * 100644 blob fb0e31ea6cc679b7379631188190e975f5789c26 Makefile
2932 * 100644 blob 5304ca4260aaddaee6498f9630e7d471b8591ea6 README
2933 * 100644 blob f931e1d229c3e185caad4449bf5b66ed72462657 tig.c
2934 * 100644 blob ed09fe897f3c7c9af90bcf80cae92558ea88ae38 web.conf
2935 */
2936
2937 #define SIZEOF_TREE_ATTR \
2938 STRING_SIZE("100644 blob ed09fe897f3c7c9af90bcf80cae92558ea88ae38\t")
2939
2940 #define TREE_UP_FORMAT "040000 tree %s\t.."
2941
2942 static int
2943 tree_compare_entry(enum line_type type1, char *name1,
2944 enum line_type type2, char *name2)
2945 {
2946 if (type1 != type2) {
2947 if (type1 == LINE_TREE_DIR)
2948 return -1;
2949 return 1;
2950 }
2951
2952 return strcmp(name1, name2);
2953 }
2954
2955 static bool
2956 tree_read(struct view *view, char *text)
2957 {
2958 size_t textlen = text ? strlen(text) : 0;
2959 char buf[SIZEOF_STR];
2960 unsigned long pos;
2961 enum line_type type;
2962 bool first_read = view->lines == 0;
2963
2964 if (textlen <= SIZEOF_TREE_ATTR)
2965 return FALSE;
2966
2967 type = text[STRING_SIZE("100644 ")] == 't'
2968 ? LINE_TREE_DIR : LINE_TREE_FILE;
2969
2970 if (first_read) {
2971 /* Add path info line */
2972 if (!string_format(buf, "Directory path /%s", opt_path) ||
2973 !realloc_lines(view, view->line_size + 1) ||
2974 !add_line_text(view, buf, LINE_DEFAULT))
2975 return FALSE;
2976
2977 /* Insert "link" to parent directory. */
2978 if (*opt_path) {
2979 if (!string_format(buf, TREE_UP_FORMAT, view->ref) ||
2980 !realloc_lines(view, view->line_size + 1) ||
2981 !add_line_text(view, buf, LINE_TREE_DIR))
2982 return FALSE;
2983 }
2984 }
2985
2986 /* Strip the path part ... */
2987 if (*opt_path) {
2988 size_t pathlen = textlen - SIZEOF_TREE_ATTR;
2989 size_t striplen = strlen(opt_path);
2990 char *path = text + SIZEOF_TREE_ATTR;
2991
2992 if (pathlen > striplen)
2993 memmove(path, path + striplen,
2994 pathlen - striplen + 1);
2995 }
2996
2997 /* Skip "Directory ..." and ".." line. */
2998 for (pos = 1 + !!*opt_path; pos < view->lines; pos++) {
2999 struct line *line = &view->line[pos];
3000 char *path1 = ((char *) line->data) + SIZEOF_TREE_ATTR;
3001 char *path2 = text + SIZEOF_TREE_ATTR;
3002 int cmp = tree_compare_entry(line->type, path1, type, path2);
3003
3004 if (cmp <= 0)
3005 continue;
3006
3007 text = strdup(text);
3008 if (!text)
3009 return FALSE;
3010
3011 if (view->lines > pos)
3012 memmove(&view->line[pos + 1], &view->line[pos],
3013 (view->lines - pos) * sizeof(*line));
3014
3015 line = &view->line[pos];
3016 line->data = text;
3017 line->type = type;
3018 view->lines++;
3019 return TRUE;
3020 }
3021
3022 if (!add_line_text(view, text, type))
3023 return FALSE;
3024
3025 if (tree_lineno > view->lineno) {
3026 view->lineno = tree_lineno;
3027 tree_lineno = 0;
3028 }
3029
3030 return TRUE;
3031 }
3032
3033 static enum request
3034 tree_request(struct view *view, enum request request, struct line *line)
3035 {
3036 enum open_flags flags;
3037
3038 if (request != REQ_ENTER)
3039 return request;
3040
3041 /* Cleanup the stack if the tree view is at a different tree. */
3042 while (!*opt_path && tree_stack)
3043 pop_tree_stack_entry();
3044
3045 switch (line->type) {
3046 case LINE_TREE_DIR:
3047 /* Depending on whether it is a subdir or parent (updir?) link
3048 * mangle the path buffer. */
3049 if (line == &view->line[1] && *opt_path) {
3050 pop_tree_stack_entry();
3051
3052 } else {
3053 char *data = line->data;
3054 char *basename = data + SIZEOF_TREE_ATTR;
3055
3056 push_tree_stack_entry(basename, view->lineno);
3057 }
3058
3059 /* Trees and subtrees share the same ID, so they are not not
3060 * unique like blobs. */
3061 flags = OPEN_RELOAD;
3062 request = REQ_VIEW_TREE;
3063 break;
3064
3065 case LINE_TREE_FILE:
3066 flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
3067 request = REQ_VIEW_BLOB;
3068 break;
3069
3070 default:
3071 return TRUE;
3072 }
3073
3074 open_view(view, request, flags);
3075 if (request == REQ_VIEW_TREE) {
3076 view->lineno = tree_lineno;
3077 }
3078
3079 return REQ_NONE;
3080 }
3081
3082 static void
3083 tree_select(struct view *view, struct line *line)
3084 {
3085 char *text = line->data + STRING_SIZE("100644 blob ");
3086
3087 if (line->type == LINE_TREE_FILE) {
3088 string_copy_rev(ref_blob, text);
3089
3090 } else if (line->type != LINE_TREE_DIR) {
3091 return;
3092 }
3093
3094 string_copy_rev(view->ref, text);
3095 }
3096
3097 static struct view_ops tree_ops = {
3098 "file",
3099 NULL,
3100 tree_read,
3101 pager_draw,
3102 tree_request,
3103 pager_grep,
3104 tree_select,
3105 };
3106
3107 static bool
3108 blob_read(struct view *view, char *line)
3109 {
3110 return add_line_text(view, line, LINE_DEFAULT) != NULL;
3111 }
3112
3113 static struct view_ops blob_ops = {
3114 "line",
3115 NULL,
3116 blob_read,
3117 pager_draw,
3118 pager_request,
3119 pager_grep,
3120 pager_select,
3121 };
3122
3123
3124 /*
3125 * Status backend
3126 */
3127
3128 struct status {
3129 char status;
3130 struct {
3131 mode_t mode;
3132 char rev[SIZEOF_REV];
3133 } old;
3134 struct {
3135 mode_t mode;
3136 char rev[SIZEOF_REV];
3137 } new;
3138 char name[SIZEOF_STR];
3139 };
3140
3141 static struct status stage_status;
3142 static enum line_type stage_line_type;
3143
3144 /* Get fields from the diff line:
3145 * :100644 100644 06a5d6ae9eca55be2e0e585a152e6b1336f2b20e 0000000000000000000000000000000000000000 M
3146 */
3147 static inline bool
3148 status_get_diff(struct status *file, char *buf, size_t bufsize)
3149 {
3150 char *old_mode = buf + 1;
3151 char *new_mode = buf + 8;
3152 char *old_rev = buf + 15;
3153 char *new_rev = buf + 56;
3154 char *status = buf + 97;
3155
3156 if (bufsize != 99 ||
3157 old_mode[-1] != ':' ||
3158 new_mode[-1] != ' ' ||
3159 old_rev[-1] != ' ' ||
3160 new_rev[-1] != ' ' ||
3161 status[-1] != ' ')
3162 return FALSE;
3163
3164 file->status = *status;
3165
3166 string_copy_rev(file->old.rev, old_rev);
3167 string_copy_rev(file->new.rev, new_rev);
3168
3169 file->old.mode = strtoul(old_mode, NULL, 8);
3170 file->new.mode = strtoul(new_mode, NULL, 8);
3171
3172 file->name[0] = 0;
3173
3174 return TRUE;
3175 }
3176
3177 static bool
3178 status_run(struct view *view, const char cmd[], bool diff, enum line_type type)
3179 {
3180 struct status *file = NULL;
3181 struct status *unmerged = NULL;
3182 char buf[SIZEOF_STR * 4];
3183 size_t bufsize = 0;
3184 FILE *pipe;
3185
3186 pipe = popen(cmd, "r");
3187 if (!pipe)
3188 return FALSE;
3189
3190 add_line_data(view, NULL, type);
3191
3192 while (!feof(pipe) && !ferror(pipe)) {
3193 char *sep;
3194 size_t readsize;
3195
3196 readsize = fread(buf + bufsize, 1, sizeof(buf) - bufsize, pipe);
3197 if (!readsize)
3198 break;
3199 bufsize += readsize;
3200
3201 /* Process while we have NUL chars. */
3202 while ((sep = memchr(buf, 0, bufsize))) {
3203 size_t sepsize = sep - buf + 1;
3204
3205 if (!file) {
3206 if (!realloc_lines(view, view->line_size + 1))
3207 goto error_out;
3208
3209 file = calloc(1, sizeof(*file));
3210 if (!file)
3211 goto error_out;
3212
3213 add_line_data(view, file, type);
3214 }
3215
3216 /* Parse diff info part. */
3217 if (!diff) {
3218 file->status = '?';
3219
3220 } else if (!file->status) {
3221 if (!status_get_diff(file, buf, sepsize))
3222 goto error_out;
3223
3224 bufsize -= sepsize;
3225 memmove(buf, sep + 1, bufsize);
3226
3227 sep = memchr(buf, 0, bufsize);
3228 if (!sep)
3229 break;
3230 sepsize = sep - buf + 1;
3231
3232 /* Collapse all 'M'odified entries that
3233 * follow a associated 'U'nmerged entry.
3234 */
3235 if (file->status == 'U') {
3236 unmerged = file;
3237
3238 } else if (unmerged) {
3239 int collapse = !strcmp(buf, unmerged->name);
3240
3241 unmerged = NULL;
3242 if (collapse) {
3243 free(file);
3244 view->lines--;
3245 continue;
3246 }
3247 }
3248 }
3249
3250 /* git-ls-files just delivers a NUL separated
3251 * list of file names similar to the second half
3252 * of the git-diff-* output. */
3253 string_ncopy(file->name, buf, sepsize);
3254 bufsize -= sepsize;
3255 memmove(buf, sep + 1, bufsize);
3256 file = NULL;
3257 }
3258 }
3259
3260 if (ferror(pipe)) {
3261 error_out:
3262 pclose(pipe);
3263 return FALSE;
3264 }
3265
3266 if (!view->line[view->lines - 1].data)
3267 add_line_data(view, NULL, LINE_STAT_NONE);
3268
3269 pclose(pipe);
3270 return TRUE;
3271 }
3272
3273 /* Don't show unmerged entries in the staged section. */
3274 #define STATUS_DIFF_INDEX_CMD "git diff-index -z --diff-filter=ACDMRTXB --cached HEAD"
3275 #define STATUS_DIFF_FILES_CMD "git diff-files -z"
3276 #define STATUS_LIST_OTHER_CMD \
3277 "git ls-files -z --others --exclude-per-directory=.gitignore"
3278
3279 #define STATUS_DIFF_SHOW_CMD \
3280 "git diff --root --patch-with-stat --find-copies-harder -B -C %s -- %s 2>/dev/null"
3281
3282 /* First parse staged info using git-diff-index(1), then parse unstaged
3283 * info using git-diff-files(1), and finally untracked files using
3284 * git-ls-files(1). */
3285 static bool
3286 status_open(struct view *view)
3287 {
3288 struct stat statbuf;
3289 char exclude[SIZEOF_STR];
3290 char cmd[SIZEOF_STR];
3291 unsigned long prev_lineno = view->lineno;
3292 size_t i;
3293
3294 for (i = 0; i < view->lines; i++)
3295 free(view->line[i].data);
3296 free(view->line);
3297 view->lines = view->line_size = view->lineno = 0;
3298 view->line = NULL;
3299
3300 if (!realloc_lines(view, view->line_size + 6))
3301 return FALSE;
3302
3303 if (!string_format(exclude, "%s/info/exclude", opt_git_dir))
3304 return FALSE;
3305
3306 string_copy(cmd, STATUS_LIST_OTHER_CMD);
3307
3308 if (stat(exclude, &statbuf) >= 0) {
3309 size_t cmdsize = strlen(cmd);
3310
3311 if (!string_format_from(cmd, &cmdsize, " %s", "--exclude-from=") ||
3312 sq_quote(cmd, cmdsize, exclude) >= sizeof(cmd))
3313 return FALSE;
3314 }
3315
3316 if (!status_run(view, STATUS_DIFF_INDEX_CMD, TRUE, LINE_STAT_STAGED) ||
3317 !status_run(view, STATUS_DIFF_FILES_CMD, TRUE, LINE_STAT_UNSTAGED) ||
3318 !status_run(view, cmd, FALSE, LINE_STAT_UNTRACKED))
3319 return FALSE;
3320
3321 /* If all went well restore the previous line number to stay in
3322 * the context. */
3323 if (prev_lineno < view->lines)
3324 view->lineno = prev_lineno;
3325 else
3326 view->lineno = view->lines - 1;
3327
3328 return TRUE;
3329 }
3330
3331 static bool
3332 status_draw(struct view *view, struct line *line, unsigned int lineno, bool selected)
3333 {
3334 struct status *status = line->data;
3335
3336 wmove(view->win, lineno, 0);
3337
3338 if (selected) {
3339 wattrset(view->win, get_line_attr(LINE_CURSOR));
3340 wchgat(view->win, -1, 0, LINE_CURSOR, NULL);
3341
3342 } else if (!status && line->type != LINE_STAT_NONE) {
3343 wattrset(view->win, get_line_attr(LINE_STAT_SECTION));
3344 wchgat(view->win, -1, 0, LINE_STAT_SECTION, NULL);
3345
3346 } else {
3347 wattrset(view->win, get_line_attr(line->type));
3348 }
3349
3350 if (!status) {
3351 char *text;
3352
3353 switch (line->type) {
3354 case LINE_STAT_STAGED:
3355 text = "Changes to be committed:";
3356 break;
3357
3358 case LINE_STAT_UNSTAGED:
3359 text = "Changed but not updated:";
3360 break;
3361
3362 case LINE_STAT_UNTRACKED:
3363 text = "Untracked files:";
3364 break;
3365
3366 case LINE_STAT_NONE:
3367 text = " (no files)";
3368 break;
3369
3370 default:
3371 return FALSE;
3372 }
3373
3374 waddstr(view->win, text);
3375 return TRUE;
3376 }
3377
3378 waddch(view->win, status->status);
3379 if (!selected)
3380 wattrset(view->win, A_NORMAL);
3381 wmove(view->win, lineno, 4);
3382 waddstr(view->win, status->name);
3383
3384 return TRUE;
3385 }
3386
3387 static enum request
3388 status_enter(struct view *view, struct line *line)
3389 {
3390 struct status *status = line->data;
3391 char path[SIZEOF_STR] = "";
3392 char *info;
3393 size_t cmdsize = 0;
3394
3395 if (line->type == LINE_STAT_NONE ||
3396 (!status && line[1].type == LINE_STAT_NONE)) {
3397 report("No file to diff");
3398 return REQ_NONE;
3399 }
3400
3401 if (status && sq_quote(path, 0, status->name) >= sizeof(path))
3402 return REQ_QUIT;
3403
3404 if (opt_cdup[0] &&
3405 line->type != LINE_STAT_UNTRACKED &&
3406 !string_format_from(opt_cmd, &cmdsize, "cd %s;", opt_cdup))
3407 return REQ_QUIT;
3408
3409 switch (line->type) {
3410 case LINE_STAT_STAGED:
3411 if (!string_format_from(opt_cmd, &cmdsize, STATUS_DIFF_SHOW_CMD,
3412 "--cached", path))
3413 return REQ_QUIT;
3414 if (status)
3415 info = "Staged changes to %s";
3416 else
3417 info = "Staged changes";
3418 break;
3419
3420 case LINE_STAT_UNSTAGED:
3421 if (!string_format_from(opt_cmd, &cmdsize, STATUS_DIFF_SHOW_CMD,
3422 "", path))
3423 return REQ_QUIT;
3424 if (status)
3425 info = "Unstaged changes to %s";
3426 else
3427 info = "Unstaged changes";
3428 break;
3429
3430 case LINE_STAT_UNTRACKED:
3431 if (opt_pipe)
3432 return REQ_QUIT;
3433
3434
3435 if (!status) {
3436 report("No file to show");
3437 return REQ_NONE;
3438 }
3439
3440 opt_pipe = fopen(status->name, "r");
3441 info = "Untracked file %s";
3442 break;
3443
3444 default:
3445 die("line type %d not handled in switch", line->type);
3446 }
3447
3448 open_view(view, REQ_VIEW_STAGE, OPEN_RELOAD | OPEN_SPLIT);
3449 if (view_is_displayed(VIEW(REQ_VIEW_STAGE))) {
3450 if (status) {
3451 stage_status = *status;
3452 } else {
3453 memset(&stage_status, 0, sizeof(stage_status));
3454 }
3455
3456 stage_line_type = line->type;
3457 string_format(VIEW(REQ_VIEW_STAGE)->ref, info, stage_status.name);
3458 }
3459
3460 return REQ_NONE;
3461 }
3462
3463
3464 static bool
3465 status_update_file(struct view *view, struct status *status, enum line_type type)
3466 {
3467 char cmd[SIZEOF_STR];
3468 char buf[SIZEOF_STR];
3469 size_t cmdsize = 0;
3470 size_t bufsize = 0;
3471 size_t written = 0;
3472 FILE *pipe;
3473
3474 if (opt_cdup[0] &&
3475 type != LINE_STAT_UNTRACKED &&
3476 !string_format_from(cmd, &cmdsize, "cd %s;", opt_cdup))
3477 return FALSE;
3478
3479 switch (type) {
3480 case LINE_STAT_STAGED:
3481 if (!string_format_from(buf, &bufsize, "%06o %s\t%s%c",
3482 status->old.mode,
3483 status->old.rev,
3484 status->name, 0))
3485 return FALSE;
3486
3487 string_add(cmd, cmdsize, "git update-index -z --index-info");
3488 break;
3489
3490 case LINE_STAT_UNSTAGED:
3491 case LINE_STAT_UNTRACKED:
3492 if (!string_format_from(buf, &bufsize, "%s%c", status->name, 0))
3493 return FALSE;
3494
3495 string_add(cmd, cmdsize, "git update-index -z --add --remove --stdin");
3496 break;
3497
3498 default:
3499 die("line type %d not handled in switch", type);
3500 }
3501
3502 pipe = popen(cmd, "w");
3503 if (!pipe)
3504 return FALSE;
3505
3506 while (!ferror(pipe) && written < bufsize) {
3507 written += fwrite(buf + written, 1, bufsize - written, pipe);
3508 }
3509
3510 pclose(pipe);
3511
3512 if (written != bufsize)
3513 return FALSE;
3514
3515 return TRUE;
3516 }
3517
3518 static void
3519 status_update(struct view *view)
3520 {
3521 struct line *line = &view->line[view->lineno];
3522
3523 assert(view->lines);
3524
3525 if (!line->data) {
3526 while (++line < view->line + view->lines && line->data) {
3527 if (!status_update_file(view, line->data, line->type))
3528 report("Failed to update file status");
3529 }
3530
3531 if (!line[-1].data) {
3532 report("Nothing to update");
3533 return;
3534 }
3535
3536 } else if (!status_update_file(view, line->data, line->type)) {
3537 report("Failed to update file status");
3538 }
3539 }
3540
3541 static enum request
3542 status_request(struct view *view, enum request request, struct line *line)
3543 {
3544 struct status *status = line->data;
3545
3546 switch (request) {
3547 case REQ_STATUS_UPDATE:
3548 status_update(view);
3549 break;
3550
3551 case REQ_STATUS_MERGE:
3552 open_mergetool(status->name);
3553 break;
3554
3555 case REQ_EDIT:
3556 if (!status)
3557 return request;
3558
3559 open_editor(status->status != '?', status->name);
3560 break;
3561
3562 case REQ_ENTER:
3563 /* After returning the status view has been split to
3564 * show the stage view. No further reloading is
3565 * necessary. */
3566 status_enter(view, line);
3567 return REQ_NONE;
3568
3569 case REQ_REFRESH:
3570 /* Simply reload the view. */
3571 break;
3572
3573 default:
3574 return request;
3575 }
3576
3577 open_view(view, REQ_VIEW_STATUS, OPEN_RELOAD);
3578
3579 return REQ_NONE;
3580 }
3581
3582 static void
3583 status_select(struct view *view, struct line *line)
3584 {
3585 struct status *status = line->data;
3586 char file[SIZEOF_STR] = "all files";
3587 char *text;
3588 char *key;
3589
3590 if (status && !string_format(file, "'%s'", status->name))
3591 return;
3592
3593 if (!status && line[1].type == LINE_STAT_NONE)
3594 line++;
3595
3596 switch (line->type) {
3597 case LINE_STAT_STAGED:
3598 text = "Press %s to unstage %s for commit";
3599 break;
3600
3601 case LINE_STAT_UNSTAGED:
3602 text = "Press %s to stage %s for commit";
3603 break;
3604
3605 case LINE_STAT_UNTRACKED:
3606 text = "Press %s to stage %s for addition";
3607 break;
3608
3609 case LINE_STAT_NONE:
3610 text = "Nothing to update";
3611 break;
3612
3613 default:
3614 die("line type %d not handled in switch", line->type);
3615 }
3616
3617 if (status && status->status == 'U') {
3618 text = "Press %s to resolve conflict in %s";
3619 key = get_key(REQ_STATUS_MERGE);
3620
3621 } else {
3622 key = get_key(REQ_STATUS_UPDATE);
3623 }
3624
3625 string_format(view->ref, text, key, file);
3626 }
3627
3628 static bool
3629 status_grep(struct view *view, struct line *line)
3630 {
3631 struct status *status = line->data;
3632 enum { S_STATUS, S_NAME, S_END } state;
3633 char buf[2] = "?";
3634 regmatch_t pmatch;
3635
3636 if (!status)
3637 return FALSE;
3638
3639 for (state = S_STATUS; state < S_END; state++) {
3640 char *text;
3641
3642 switch (state) {
3643 case S_NAME: text = status->name; break;
3644 case S_STATUS:
3645 buf[0] = status->status;
3646 text = buf;
3647 break;
3648
3649 default:
3650 return FALSE;
3651 }
3652
3653 if (regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
3654 return TRUE;
3655 }
3656
3657 return FALSE;
3658 }
3659
3660 static struct view_ops status_ops = {
3661 "file",
3662 status_open,
3663 NULL,
3664 status_draw,
3665 status_request,
3666 status_grep,
3667 status_select,
3668 };
3669
3670
3671 static bool
3672 stage_diff_line(FILE *pipe, struct line *line)
3673 {
3674 char *buf = line->data;
3675 size_t bufsize = strlen(buf);
3676 size_t written = 0;
3677
3678 while (!ferror(pipe) && written < bufsize) {
3679 written += fwrite(buf + written, 1, bufsize - written, pipe);
3680 }
3681
3682 fputc('\n', pipe);
3683
3684 return written == bufsize;
3685 }
3686
3687 static struct line *
3688 stage_diff_hdr(struct view *view, struct line *line)
3689 {
3690 int diff_hdr_dir = line->type == LINE_DIFF_CHUNK ? -1 : 1;
3691 struct line *diff_hdr;
3692
3693 if (line->type == LINE_DIFF_CHUNK)
3694 diff_hdr = line - 1;
3695 else
3696 diff_hdr = view->line + 1;
3697
3698 while (diff_hdr > view->line && diff_hdr < view->line + view->lines) {
3699 if (diff_hdr->type == LINE_DIFF_HEADER)
3700 return diff_hdr;
3701
3702 diff_hdr += diff_hdr_dir;
3703 }
3704
3705 return NULL;
3706 }
3707
3708 static bool
3709 stage_update_chunk(struct view *view, struct line *line)
3710 {
3711 char cmd[SIZEOF_STR];
3712 size_t cmdsize = 0;
3713 struct line *diff_hdr, *diff_chunk, *diff_end;
3714 FILE *pipe;
3715
3716 diff_hdr = stage_diff_hdr(view, line);
3717 if (!diff_hdr)
3718 return FALSE;
3719
3720 if (opt_cdup[0] &&
3721 !string_format_from(cmd, &cmdsize, "cd %s;", opt_cdup))
3722 return FALSE;
3723
3724 if (!string_format_from(cmd, &cmdsize,
3725 "git apply --cached %s - && "
3726 "git update-index -q --unmerged --refresh 2>/dev/null",
3727 stage_line_type == LINE_STAT_STAGED ? "-R" : ""))
3728 return FALSE;
3729
3730 pipe = popen(cmd, "w");
3731 if (!pipe)
3732 return FALSE;
3733
3734 diff_end = view->line + view->lines;
3735 if (line->type != LINE_DIFF_CHUNK) {
3736 diff_chunk = diff_hdr;
3737
3738 } else {
3739 for (diff_chunk = line + 1; diff_chunk < diff_end; diff_chunk++)
3740 if (diff_chunk->type == LINE_DIFF_CHUNK ||
3741 diff_chunk->type == LINE_DIFF_HEADER)
3742 diff_end = diff_chunk;
3743
3744 diff_chunk = line;
3745
3746 while (diff_hdr->type != LINE_DIFF_CHUNK) {
3747 switch (diff_hdr->type) {
3748 case LINE_DIFF_HEADER:
3749 case LINE_DIFF_INDEX:
3750 case LINE_DIFF_ADD:
3751 case LINE_DIFF_DEL:
3752 break;
3753
3754 default:
3755 diff_hdr++;
3756 continue;
3757 }
3758
3759 if (!stage_diff_line(pipe, diff_hdr++)) {
3760 pclose(pipe);
3761 return FALSE;
3762 }
3763 }
3764 }
3765
3766 while (diff_chunk < diff_end && stage_diff_line(pipe, diff_chunk))
3767 diff_chunk++;
3768
3769 pclose(pipe);
3770
3771 if (diff_chunk != diff_end)
3772 return FALSE;
3773
3774 return TRUE;
3775 }
3776
3777 static void
3778 stage_update(struct view *view, struct line *line)
3779 {
3780 if (stage_line_type != LINE_STAT_UNTRACKED &&
3781 (line->type == LINE_DIFF_CHUNK || !stage_status.status)) {
3782 if (!stage_update_chunk(view, line)) {
3783 report("Failed to apply chunk");
3784 return;
3785 }
3786
3787 } else if (!status_update_file(view, &stage_status, stage_line_type)) {
3788 report("Failed to update file");
3789 return;
3790 }
3791
3792 open_view(view, REQ_VIEW_STATUS, OPEN_RELOAD);
3793
3794 view = VIEW(REQ_VIEW_STATUS);
3795 if (view_is_displayed(view))
3796 status_enter(view, &view->line[view->lineno]);
3797 }
3798
3799 static enum request
3800 stage_request(struct view *view, enum request request, struct line *line)
3801 {
3802 switch (request) {
3803 case REQ_STATUS_UPDATE:
3804 stage_update(view, line);
3805 break;
3806
3807 case REQ_EDIT:
3808 if (!stage_status.name[0])
3809 return request;
3810
3811 open_editor(stage_status.status != '?', stage_status.name);
3812 break;
3813
3814 case REQ_ENTER:
3815 pager_request(view, request, line);
3816 break;
3817
3818 default:
3819 return request;
3820 }
3821
3822 return REQ_NONE;
3823 }
3824
3825 static struct view_ops stage_ops = {
3826 "line",
3827 NULL,
3828 pager_read,
3829 pager_draw,
3830 stage_request,
3831 pager_grep,
3832 pager_select,
3833 };
3834
3835
3836 /*
3837 * Revision graph
3838 */
3839
3840 struct commit {
3841 char id[SIZEOF_REV]; /* SHA1 ID. */
3842 char title[128]; /* First line of the commit message. */
3843 char author[75]; /* Author of the commit. */
3844 struct tm time; /* Date from the author ident. */
3845 struct ref **refs; /* Repository references. */
3846 chtype graph[SIZEOF_REVGRAPH]; /* Ancestry chain graphics. */
3847 size_t graph_size; /* The width of the graph array. */
3848 };
3849
3850 /* Size of rev graph with no "padding" columns */
3851 #define SIZEOF_REVITEMS (SIZEOF_REVGRAPH - (SIZEOF_REVGRAPH / 2))
3852
3853 struct rev_graph {
3854 struct rev_graph *prev, *next, *parents;
3855 char rev[SIZEOF_REVITEMS][SIZEOF_REV];
3856 size_t size;
3857 struct commit *commit;
3858 size_t pos;
3859 };
3860
3861 /* Parents of the commit being visualized. */
3862 static struct rev_graph graph_parents[4];
3863
3864 /* The current stack of revisions on the graph. */
3865 static struct rev_graph graph_stacks[4] = {
3866 { &graph_stacks[3], &graph_stacks[1], &graph_parents[0] },
3867 { &graph_stacks[0], &graph_stacks[2], &graph_parents[1] },
3868 { &graph_stacks[1], &graph_stacks[3], &graph_parents[2] },
3869 { &graph_stacks[2], &graph_stacks[0], &graph_parents[3] },
3870 };
3871
3872 static inline bool
3873 graph_parent_is_merge(struct rev_graph *graph)
3874 {
3875 return graph->parents->size > 1;
3876 }
3877
3878 static inline void
3879 append_to_rev_graph(struct rev_graph *graph, chtype symbol)
3880 {
3881 struct commit *commit = graph->commit;
3882
3883 if (commit->graph_size < ARRAY_SIZE(commit->graph) - 1)
3884 commit->graph[commit->graph_size++] = symbol;
3885 }
3886
3887 static void
3888 done_rev_graph(struct rev_graph *graph)
3889 {
3890 if (graph_parent_is_merge(graph) &&
3891 graph->pos < graph->size - 1 &&
3892 graph->next->size == graph->size + graph->parents->size - 1) {
3893 size_t i = graph->pos + graph->parents->size - 1;
3894
3895 graph->commit->graph_size = i * 2;
3896 while (i < graph->next->size - 1) {
3897 append_to_rev_graph(graph, ' ');
3898 append_to_rev_graph(graph, '\\');
3899 i++;
3900 }
3901 }
3902
3903 graph->size = graph->pos = 0;
3904 graph->commit = NULL;
3905 memset(graph->parents, 0, sizeof(*graph->parents));
3906 }
3907
3908 static void
3909 push_rev_graph(struct rev_graph *graph, char *parent)
3910 {
3911 int i;
3912
3913 /* "Collapse" duplicate parents lines.
3914 *
3915 * FIXME: This needs to also update update the drawn graph but
3916 * for now it just serves as a method for pruning graph lines. */
3917 for (i = 0; i < graph->size; i++)
3918 if (!strncmp(graph->rev[i], parent, SIZEOF_REV))
3919 return;
3920
3921 if (graph->size < SIZEOF_REVITEMS) {
3922 string_copy_rev(graph->rev[graph->size++], parent);
3923 }
3924 }
3925
3926 static chtype
3927 get_rev_graph_symbol(struct rev_graph *graph)
3928 {
3929 chtype symbol;
3930
3931 if (graph->parents->size == 0)
3932 symbol = REVGRAPH_INIT;
3933 else if (graph_parent_is_merge(graph))
3934 symbol = REVGRAPH_MERGE;
3935 else if (graph->pos >= graph->size)
3936 symbol = REVGRAPH_BRANCH;
3937 else
3938 symbol = REVGRAPH_COMMIT;
3939
3940 return symbol;
3941 }
3942
3943 static void
3944 draw_rev_graph(struct rev_graph *graph)
3945 {
3946 struct rev_filler {
3947 chtype separator, line;
3948 };
3949 enum { DEFAULT, RSHARP, RDIAG, LDIAG };
3950 static struct rev_filler fillers[] = {
3951 { ' ', REVGRAPH_LINE },
3952 { '`', '.' },
3953 { '\'', ' ' },
3954 { '/', ' ' },
3955 };
3956 chtype symbol = get_rev_graph_symbol(graph);
3957 struct rev_filler *filler;
3958 size_t i;
3959
3960 filler = &fillers[DEFAULT];
3961
3962 for (i = 0; i < graph->pos; i++) {
3963 append_to_rev_graph(graph, filler->line);
3964 if (graph_parent_is_merge(graph->prev) &&
3965 graph->prev->pos == i)
3966 filler = &fillers[RSHARP];
3967
3968 append_to_rev_graph(graph, filler->separator);
3969 }
3970
3971 /* Place the symbol for this revision. */
3972 append_to_rev_graph(graph, symbol);
3973
3974 if (graph->prev->size > graph->size)
3975 filler = &fillers[RDIAG];
3976 else
3977 filler = &fillers[DEFAULT];
3978
3979 i++;
3980
3981 for (; i < graph->size; i++) {
3982 append_to_rev_graph(graph, filler->separator);
3983 append_to_rev_graph(graph, filler->line);
3984 if (graph_parent_is_merge(graph->prev) &&
3985 i < graph->prev->pos + graph->parents->size)
3986 filler = &fillers[RSHARP];
3987 if (graph->prev->size > graph->size)
3988 filler = &fillers[LDIAG];
3989 }
3990
3991 if (graph->prev->size > graph->size) {
3992 append_to_rev_graph(graph, filler->separator);
3993 if (filler->line != ' ')
3994 append_to_rev_graph(graph, filler->line);
3995 }
3996 }
3997
3998 /* Prepare the next rev graph */
3999 static void
4000 prepare_rev_graph(struct rev_graph *graph)
4001 {
4002 size_t i;
4003
4004 /* First, traverse all lines of revisions up to the active one. */
4005 for (graph->pos = 0; graph->pos < graph->size; graph->pos++) {
4006 if (!strcmp(graph->rev[graph->pos], graph->commit->id))
4007 break;
4008
4009 push_rev_graph(graph->next, graph->rev[graph->pos]);
4010 }
4011
4012 /* Interleave the new revision parent(s). */
4013 for (i = 0; i < graph->parents->size; i++)
4014 push_rev_graph(graph->next, graph->parents->rev[i]);
4015
4016 /* Lastly, put any remaining revisions. */
4017 for (i = graph->pos + 1; i < graph->size; i++)
4018 push_rev_graph(graph->next, graph->rev[i]);
4019 }
4020
4021 static void
4022 update_rev_graph(struct rev_graph *graph)
4023 {
4024 /* If this is the finalizing update ... */
4025 if (graph->commit)
4026 prepare_rev_graph(graph);
4027
4028 /* Graph visualization needs a one rev look-ahead,
4029 * so the first update doesn't visualize anything. */
4030 if (!graph->prev->commit)
4031 return;
4032
4033 draw_rev_graph(graph->prev);
4034 done_rev_graph(graph->prev->prev);
4035 }
4036
4037
4038 /*
4039 * Main view backend
4040 */
4041
4042 static bool
4043 main_draw(struct view *view, struct line *line, unsigned int lineno, bool selected)
4044 {
4045 char buf[DATE_COLS + 1];
4046 struct commit *commit = line->data;
4047 enum line_type type;
4048 int col = 0;
4049 size_t timelen;
4050 size_t authorlen;
4051 int trimmed = 1;
4052
4053 if (!*commit->author)
4054 return FALSE;
4055
4056 wmove(view->win, lineno, col);
4057
4058 if (selected) {
4059 type = LINE_CURSOR;
4060 wattrset(view->win, get_line_attr(type));
4061 wchgat(view->win, -1, 0, type, NULL);
4062
4063 } else {
4064 type = LINE_MAIN_COMMIT;
4065 wattrset(view->win, get_line_attr(LINE_MAIN_DATE));
4066 }
4067
4068 timelen = strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time);
4069 waddnstr(view->win, buf, timelen);
4070 waddstr(view->win, " ");
4071
4072 col += DATE_COLS;
4073 wmove(view->win, lineno, col);
4074 if (type != LINE_CURSOR)
4075 wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
4076
4077 if (opt_utf8) {
4078 authorlen = utf8_length(commit->author, AUTHOR_COLS - 2, &col, &trimmed);
4079 } else {
4080 authorlen = strlen(commit->author);
4081 if (authorlen > AUTHOR_COLS - 2) {
4082 authorlen = AUTHOR_COLS - 2;
4083 trimmed = 1;
4084 }
4085 }
4086
4087 if (trimmed) {
4088 waddnstr(view->win, commit->author, authorlen);
4089 if (type != LINE_CURSOR)
4090 wattrset(view->win, get_line_attr(LINE_MAIN_DELIM));
4091 waddch(view->win, '~');
4092 } else {
4093 waddstr(view->win, commit->author);
4094 }
4095
4096 col += AUTHOR_COLS;
4097 if (type != LINE_CURSOR)
4098 wattrset(view->win, A_NORMAL);
4099
4100 if (opt_rev_graph && commit->graph_size) {
4101 size_t i;
4102
4103 wmove(view->win, lineno, col);
4104 /* Using waddch() instead of waddnstr() ensures that
4105 * they'll be rendered correctly for the cursor line. */
4106 for (i = 0; i < commit->graph_size; i++)
4107 waddch(view->win, commit->graph[i]);
4108
4109 waddch(view->win, ' ');
4110 col += commit->graph_size + 1;
4111 }
4112
4113 wmove(view->win, lineno, col);
4114
4115 if (commit->refs) {
4116 size_t i = 0;
4117
4118 do {
4119 if (type == LINE_CURSOR)
4120 ;
4121 else if (commit->refs[i]->tag)
4122 wattrset(view->win, get_line_attr(LINE_MAIN_TAG));
4123 else if (commit->refs[i]->remote)
4124 wattrset(view->win, get_line_attr(LINE_MAIN_REMOTE));
4125 else
4126 wattrset(view->win, get_line_attr(LINE_MAIN_REF));
4127 waddstr(view->win, "[");
4128 waddstr(view->win, commit->refs[i]->name);
4129 waddstr(view->win, "]");
4130 if (type != LINE_CURSOR)
4131 wattrset(view->win, A_NORMAL);
4132 waddstr(view->win, " ");
4133 col += strlen(commit->refs[i]->name) + STRING_SIZE("[] ");
4134 } while (commit->refs[i++]->next);
4135 }
4136
4137 if (type != LINE_CURSOR)
4138 wattrset(view->win, get_line_attr(type));
4139
4140 {
4141 int titlelen = strlen(commit->title);
4142
4143 if (col + titlelen > view->width)
4144 titlelen = view->width - col;
4145
4146 waddnstr(view->win, commit->title, titlelen);
4147 }
4148
4149 return TRUE;
4150 }
4151
4152 /* Reads git log --pretty=raw output and parses it into the commit struct. */
4153 static bool
4154 main_read(struct view *view, char *line)
4155 {
4156 static struct rev_graph *graph = graph_stacks;
4157 enum line_type type;
4158 struct commit *commit;
4159
4160 if (!line) {
4161 update_rev_graph(graph);
4162 return TRUE;
4163 }
4164
4165 type = get_line_type(line);
4166 if (type == LINE_COMMIT) {
4167 commit = calloc(1, sizeof(struct commit));
4168 if (!commit)
4169 return FALSE;
4170
4171 string_copy_rev(commit->id, line + STRING_SIZE("commit "));
4172 commit->refs = get_refs(commit->id);
4173 graph->commit = commit;
4174 add_line_data(view, commit, LINE_MAIN_COMMIT);
4175 return TRUE;
4176 }
4177
4178 if (!view->lines)
4179 return TRUE;
4180 commit = view->line[view->lines - 1].data;
4181
4182 switch (type) {
4183 case LINE_PARENT:
4184 push_rev_graph(graph->parents, line + STRING_SIZE("parent "));
4185 break;
4186
4187 case LINE_AUTHOR:
4188 {
4189 /* Parse author lines where the name may be empty:
4190 * author <email@address.tld> 1138474660 +0100
4191 */
4192 char *ident = line + STRING_SIZE("author ");
4193 char *nameend = strchr(ident, '<');
4194 char *emailend = strchr(ident, '>');
4195
4196 if (!nameend || !emailend)
4197 break;
4198
4199 update_rev_graph(graph);
4200 graph = graph->next;
4201
4202 *nameend = *emailend = 0;
4203 ident = chomp_string(ident);
4204 if (!*ident) {
4205 ident = chomp_string(nameend + 1);
4206 if (!*ident)
4207 ident = "Unknown";
4208 }
4209
4210 string_ncopy(commit->author, ident, strlen(ident));
4211
4212 /* Parse epoch and timezone */
4213 if (emailend[1] == ' ') {
4214 char *secs = emailend + 2;
4215 char *zone = strchr(secs, ' ');
4216 time_t time = (time_t) atol(secs);
4217
4218 if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
4219 long tz;
4220
4221 zone++;
4222 tz = ('0' - zone[1]) * 60 * 60 * 10;
4223 tz += ('0' - zone[2]) * 60 * 60;
4224 tz += ('0' - zone[3]) * 60;
4225 tz += ('0' - zone[4]) * 60;
4226
4227 if (zone[0] == '-')
4228 tz = -tz;
4229
4230 time -= tz;
4231 }
4232
4233 gmtime_r(&time, &commit->time);
4234 }
4235 break;
4236 }
4237 default:
4238 /* Fill in the commit title if it has not already been set. */
4239 if (commit->title[0])
4240 break;
4241
4242 /* Require titles to start with a non-space character at the
4243 * offset used by git log. */
4244 if (strncmp(line, " ", 4))
4245 break;
4246 line += 4;
4247 /* Well, if the title starts with a whitespace character,
4248 * try to be forgiving. Otherwise we end up with no title. */
4249 while (isspace(*line))
4250 line++;
4251 if (*line == '\0')
4252 break;
4253 /* FIXME: More graceful handling of titles; append "..." to
4254 * shortened titles, etc. */
4255
4256 string_ncopy(commit->title, line, strlen(line));
4257 }
4258
4259 return TRUE;
4260 }
4261
4262 static enum request
4263 main_request(struct view *view, enum request request, struct line *line)
4264 {
4265 enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
4266
4267 if (request == REQ_ENTER)
4268 open_view(view, REQ_VIEW_DIFF, flags);
4269 else
4270 return request;
4271
4272 return REQ_NONE;
4273 }
4274
4275 static bool
4276 main_grep(struct view *view, struct line *line)
4277 {
4278 struct commit *commit = line->data;
4279 enum { S_TITLE, S_AUTHOR, S_DATE, S_END } state;
4280 char buf[DATE_COLS + 1];
4281 regmatch_t pmatch;
4282
4283 for (state = S_TITLE; state < S_END; state++) {
4284 char *text;
4285
4286 switch (state) {
4287 case S_TITLE: text = commit->title; break;
4288 case S_AUTHOR: text = commit->author; break;
4289 case S_DATE:
4290 if (!strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time))
4291 continue;
4292 text = buf;
4293 break;
4294
4295 default:
4296 return FALSE;
4297 }
4298
4299 if (regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
4300 return TRUE;
4301 }
4302
4303 return FALSE;
4304 }
4305
4306 static void
4307 main_select(struct view *view, struct line *line)
4308 {
4309 struct commit *commit = line->data;
4310
4311 string_copy_rev(view->ref, commit->id);
4312 string_copy_rev(ref_commit, view->ref);
4313 }
4314
4315 static struct view_ops main_ops = {
4316 "commit",
4317 NULL,
4318 main_read,
4319 main_draw,
4320 main_request,
4321 main_grep,
4322 main_select,
4323 };
4324
4325
4326 /*
4327 * Unicode / UTF-8 handling
4328 *
4329 * NOTE: Much of the following code for dealing with unicode is derived from
4330 * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
4331 * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
4332 */
4333
4334 /* I've (over)annotated a lot of code snippets because I am not entirely
4335 * confident that the approach taken by this small UTF-8 interface is correct.
4336 * --jonas */
4337
4338 static inline int
4339 unicode_width(unsigned long c)
4340 {
4341 if (c >= 0x1100 &&
4342 (c <= 0x115f /* Hangul Jamo */
4343 || c == 0x2329
4344 || c == 0x232a
4345 || (c >= 0x2e80 && c <= 0xa4cf && c != 0x303f)
4346 /* CJK ... Yi */
4347 || (c >= 0xac00 && c <= 0xd7a3) /* Hangul Syllables */
4348 || (c >= 0xf900 && c <= 0xfaff) /* CJK Compatibility Ideographs */
4349 || (c >= 0xfe30 && c <= 0xfe6f) /* CJK Compatibility Forms */
4350 || (c >= 0xff00 && c <= 0xff60) /* Fullwidth Forms */
4351 || (c >= 0xffe0 && c <= 0xffe6)
4352 || (c >= 0x20000 && c <= 0x2fffd)
4353 || (c >= 0x30000 && c <= 0x3fffd)))
4354 return 2;
4355
4356 return 1;
4357 }
4358
4359 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
4360 * Illegal bytes are set one. */
4361 static const unsigned char utf8_bytes[256] = {
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 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,
4368 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,
4369 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,
4370 };
4371
4372 /* Decode UTF-8 multi-byte representation into a unicode character. */
4373 static inline unsigned long
4374 utf8_to_unicode(const char *string, size_t length)
4375 {
4376 unsigned long unicode;
4377
4378 switch (length) {
4379 case 1:
4380 unicode = string[0];
4381 break;
4382 case 2:
4383 unicode = (string[0] & 0x1f) << 6;
4384 unicode += (string[1] & 0x3f);
4385 break;
4386 case 3:
4387 unicode = (string[0] & 0x0f) << 12;
4388 unicode += ((string[1] & 0x3f) << 6);
4389 unicode += (string[2] & 0x3f);
4390 break;
4391 case 4:
4392 unicode = (string[0] & 0x0f) << 18;
4393 unicode += ((string[1] & 0x3f) << 12);
4394 unicode += ((string[2] & 0x3f) << 6);
4395 unicode += (string[3] & 0x3f);
4396 break;
4397 case 5:
4398 unicode = (string[0] & 0x0f) << 24;
4399 unicode += ((string[1] & 0x3f) << 18);
4400 unicode += ((string[2] & 0x3f) << 12);
4401 unicode += ((string[3] & 0x3f) << 6);
4402 unicode += (string[4] & 0x3f);
4403 break;
4404 case 6:
4405 unicode = (string[0] & 0x01) << 30;
4406 unicode += ((string[1] & 0x3f) << 24);
4407 unicode += ((string[2] & 0x3f) << 18);
4408 unicode += ((string[3] & 0x3f) << 12);
4409 unicode += ((string[4] & 0x3f) << 6);
4410 unicode += (string[5] & 0x3f);
4411 break;
4412 default:
4413 die("Invalid unicode length");
4414 }
4415
4416 /* Invalid characters could return the special 0xfffd value but NUL
4417 * should be just as good. */
4418 return unicode > 0xffff ? 0 : unicode;
4419 }
4420
4421 /* Calculates how much of string can be shown within the given maximum width
4422 * and sets trimmed parameter to non-zero value if all of string could not be
4423 * shown.
4424 *
4425 * Additionally, adds to coloffset how many many columns to move to align with
4426 * the expected position. Takes into account how multi-byte and double-width
4427 * characters will effect the cursor position.
4428 *
4429 * Returns the number of bytes to output from string to satisfy max_width. */
4430 static size_t
4431 utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed)
4432 {
4433 const char *start = string;
4434 const char *end = strchr(string, '\0');
4435 size_t mbwidth = 0;
4436 size_t width = 0;
4437
4438 *trimmed = 0;
4439
4440 while (string < end) {
4441 int c = *(unsigned char *) string;
4442 unsigned char bytes = utf8_bytes[c];
4443 size_t ucwidth;
4444 unsigned long unicode;
4445
4446 if (string + bytes > end)
4447 break;
4448
4449 /* Change representation to figure out whether
4450 * it is a single- or double-width character. */
4451
4452 unicode = utf8_to_unicode(string, bytes);
4453 /* FIXME: Graceful handling of invalid unicode character. */
4454 if (!unicode)
4455 break;
4456
4457 ucwidth = unicode_width(unicode);
4458 width += ucwidth;
4459 if (width > max_width) {
4460 *trimmed = 1;
4461 break;
4462 }
4463
4464 /* The column offset collects the differences between the
4465 * number of bytes encoding a character and the number of
4466 * columns will be used for rendering said character.
4467 *
4468 * So if some character A is encoded in 2 bytes, but will be
4469 * represented on the screen using only 1 byte this will and up
4470 * adding 1 to the multi-byte column offset.
4471 *
4472 * Assumes that no double-width character can be encoding in
4473 * less than two bytes. */
4474 if (bytes > ucwidth)
4475 mbwidth += bytes - ucwidth;
4476
4477 string += bytes;
4478 }
4479
4480 *coloffset += mbwidth;
4481
4482 return string - start;
4483 }
4484
4485
4486 /*
4487 * Status management
4488 */
4489
4490 /* Whether or not the curses interface has been initialized. */
4491 static bool cursed = FALSE;
4492
4493 /* The status window is used for polling keystrokes. */
4494 static WINDOW *status_win;
4495
4496 static bool status_empty = TRUE;
4497
4498 /* Update status and title window. */
4499 static void
4500 report(const char *msg, ...)
4501 {
4502 struct view *view = display[current_view];
4503
4504 if (input_mode)
4505 return;
4506
4507 if (!view) {
4508 char buf[SIZEOF_STR];
4509 va_list args;
4510
4511 va_start(args, msg);
4512 if (vsnprintf(buf, sizeof(buf), msg, args) >= sizeof(buf)) {
4513 buf[sizeof(buf) - 1] = 0;
4514 buf[sizeof(buf) - 2] = '.';
4515 buf[sizeof(buf) - 3] = '.';
4516 buf[sizeof(buf) - 4] = '.';
4517 }
4518 va_end(args);
4519 die("%s", buf);
4520 }
4521
4522 if (!status_empty || *msg) {
4523 va_list args;
4524
4525 va_start(args, msg);
4526
4527 wmove(status_win, 0, 0);
4528 if (*msg) {
4529 vwprintw(status_win, msg, args);
4530 status_empty = FALSE;
4531 } else {
4532 status_empty = TRUE;
4533 }
4534 wclrtoeol(status_win);
4535 wrefresh(status_win);
4536
4537 va_end(args);
4538 }
4539
4540 update_view_title(view);
4541 update_display_cursor(view);
4542 }
4543
4544 /* Controls when nodelay should be in effect when polling user input. */
4545 static void
4546 set_nonblocking_input(bool loading)
4547 {
4548 static unsigned int loading_views;
4549
4550 if ((loading == FALSE && loading_views-- == 1) ||
4551 (loading == TRUE && loading_views++ == 0))
4552 nodelay(status_win, loading);
4553 }
4554
4555 static void
4556 init_display(void)
4557 {
4558 int x, y;
4559
4560 /* Initialize the curses library */
4561 if (isatty(STDIN_FILENO)) {
4562 cursed = !!initscr();
4563 } else {
4564 /* Leave stdin and stdout alone when acting as a pager. */
4565 FILE *io = fopen("/dev/tty", "r+");
4566
4567 if (!io)
4568 die("Failed to open /dev/tty");
4569 cursed = !!newterm(NULL, io, io);
4570 }
4571
4572 if (!cursed)
4573 die("Failed to initialize curses");
4574
4575 nonl(); /* Tell curses not to do NL->CR/NL on output */
4576 cbreak(); /* Take input chars one at a time, no wait for \n */
4577 noecho(); /* Don't echo input */
4578 leaveok(stdscr, TRUE);
4579
4580 if (has_colors())
4581 init_colors();
4582
4583 getmaxyx(stdscr, y, x);
4584 status_win = newwin(1, 0, y - 1, 0);
4585 if (!status_win)
4586 die("Failed to create status window");
4587
4588 /* Enable keyboard mapping */
4589 keypad(status_win, TRUE);
4590 wbkgdset(status_win, get_line_attr(LINE_STATUS));
4591 }
4592
4593 static char *
4594 read_prompt(const char *prompt)
4595 {
4596 enum { READING, STOP, CANCEL } status = READING;
4597 static char buf[sizeof(opt_cmd) - STRING_SIZE("git \0")];
4598 int pos = 0;
4599
4600 while (status == READING) {
4601 struct view *view;
4602 int i, key;
4603
4604 input_mode = TRUE;
4605
4606 foreach_view (view, i)
4607 update_view(view);
4608
4609 input_mode = FALSE;
4610
4611 mvwprintw(status_win, 0, 0, "%s%.*s", prompt, pos, buf);
4612 wclrtoeol(status_win);
4613
4614 /* Refresh, accept single keystroke of input */
4615 key = wgetch(status_win);
4616 switch (key) {
4617 case KEY_RETURN:
4618 case KEY_ENTER:
4619 case '\n':
4620 status = pos ? STOP : CANCEL;
4621 break;
4622
4623 case KEY_BACKSPACE:
4624 if (pos > 0)
4625 pos--;
4626 else
4627 status = CANCEL;
4628 break;
4629
4630 case KEY_ESC:
4631 status = CANCEL;
4632 break;
4633
4634 case ERR:
4635 break;
4636
4637 default:
4638 if (pos >= sizeof(buf)) {
4639 report("Input string too long");
4640 return NULL;
4641 }
4642
4643 if (isprint(key))
4644 buf[pos++] = (char) key;
4645 }
4646 }
4647
4648 /* Clear the status window */
4649 status_empty = FALSE;
4650 report("");
4651
4652 if (status == CANCEL)
4653 return NULL;
4654
4655 buf[pos++] = 0;
4656
4657 return buf;
4658 }
4659
4660 /*
4661 * Repository references
4662 */
4663
4664 static struct ref *refs;
4665 static size_t refs_size;
4666
4667 /* Id <-> ref store */
4668 static struct ref ***id_refs;
4669 static size_t id_refs_size;
4670
4671 static struct ref **
4672 get_refs(char *id)
4673 {
4674 struct ref ***tmp_id_refs;
4675 struct ref **ref_list = NULL;
4676 size_t ref_list_size = 0;
4677 size_t i;
4678
4679 for (i = 0; i < id_refs_size; i++)
4680 if (!strcmp(id, id_refs[i][0]->id))
4681 return id_refs[i];
4682
4683 tmp_id_refs = realloc(id_refs, (id_refs_size + 1) * sizeof(*id_refs));
4684 if (!tmp_id_refs)
4685 return NULL;
4686
4687 id_refs = tmp_id_refs;
4688
4689 for (i = 0; i < refs_size; i++) {
4690 struct ref **tmp;
4691
4692 if (strcmp(id, refs[i].id))
4693 continue;
4694
4695 tmp = realloc(ref_list, (ref_list_size + 1) * sizeof(*ref_list));
4696 if (!tmp) {
4697 if (ref_list)
4698 free(ref_list);
4699 return NULL;
4700 }
4701
4702 ref_list = tmp;
4703 if (ref_list_size > 0)
4704 ref_list[ref_list_size - 1]->next = 1;
4705 ref_list[ref_list_size] = &refs[i];
4706
4707 /* XXX: The properties of the commit chains ensures that we can
4708 * safely modify the shared ref. The repo references will
4709 * always be similar for the same id. */
4710 ref_list[ref_list_size]->next = 0;
4711 ref_list_size++;
4712 }
4713
4714 if (ref_list)
4715 id_refs[id_refs_size++] = ref_list;
4716
4717 return ref_list;
4718 }
4719
4720 static int
4721 read_ref(char *id, size_t idlen, char *name, size_t namelen)
4722 {
4723 struct ref *ref;
4724 bool tag = FALSE;
4725 bool remote = FALSE;
4726
4727 if (!strncmp(name, "refs/tags/", STRING_SIZE("refs/tags/"))) {
4728 /* Commits referenced by tags has "^{}" appended. */
4729 if (name[namelen - 1] != '}')
4730 return OK;
4731
4732 while (namelen > 0 && name[namelen] != '^')
4733 namelen--;
4734
4735 tag = TRUE;
4736 namelen -= STRING_SIZE("refs/tags/");
4737 name += STRING_SIZE("refs/tags/");
4738
4739 } else if (!strncmp(name, "refs/remotes/", STRING_SIZE("refs/remotes/"))) {
4740 remote = TRUE;
4741 namelen -= STRING_SIZE("refs/remotes/");
4742 name += STRING_SIZE("refs/remotes/");
4743
4744 } else if (!strncmp(name, "refs/heads/", STRING_SIZE("refs/heads/"))) {
4745 namelen -= STRING_SIZE("refs/heads/");
4746 name += STRING_SIZE("refs/heads/");
4747
4748 } else if (!strcmp(name, "HEAD")) {
4749 return OK;
4750 }
4751
4752 refs = realloc(refs, sizeof(*refs) * (refs_size + 1));
4753 if (!refs)
4754 return ERR;
4755
4756 ref = &refs[refs_size++];
4757 ref->name = malloc(namelen + 1);
4758 if (!ref->name)
4759 return ERR;
4760
4761 strncpy(ref->name, name, namelen);
4762 ref->name[namelen] = 0;
4763 ref->tag = tag;
4764 ref->remote = remote;
4765 string_copy_rev(ref->id, id);
4766
4767 return OK;
4768 }
4769
4770 static int
4771 load_refs(void)
4772 {
4773 const char *cmd_env = getenv("TIG_LS_REMOTE");
4774 const char *cmd = cmd_env && *cmd_env ? cmd_env : TIG_LS_REMOTE;
4775
4776 return read_properties(popen(cmd, "r"), "\t", read_ref);
4777 }
4778
4779 static int
4780 read_repo_config_option(char *name, size_t namelen, char *value, size_t valuelen)
4781 {
4782 if (!strcmp(name, "i18n.commitencoding"))
4783 string_ncopy(opt_encoding, value, valuelen);
4784
4785 if (!strcmp(name, "core.editor"))
4786 string_ncopy(opt_editor, value, valuelen);
4787
4788 return OK;
4789 }
4790
4791 static int
4792 load_repo_config(void)
4793 {
4794 return read_properties(popen(GIT_CONFIG " --list", "r"),
4795 "=", read_repo_config_option);
4796 }
4797
4798 static int
4799 read_repo_info(char *name, size_t namelen, char *value, size_t valuelen)
4800 {
4801 if (!opt_git_dir[0]) {
4802 string_ncopy(opt_git_dir, name, namelen);
4803
4804 } else if (opt_is_inside_work_tree == -1) {
4805 /* This can be 3 different values depending on the
4806 * version of git being used. If git-rev-parse does not
4807 * understand --is-inside-work-tree it will simply echo
4808 * the option else either "true" or "false" is printed.
4809 * Default to true for the unknown case. */
4810 opt_is_inside_work_tree = strcmp(name, "false") ? TRUE : FALSE;
4811
4812 } else {
4813 string_ncopy(opt_cdup, name, namelen);
4814 }
4815
4816 return OK;
4817 }
4818
4819 /* XXX: The line outputted by "--show-cdup" can be empty so the option
4820 * must be the last one! */
4821 static int
4822 load_repo_info(void)
4823 {
4824 return read_properties(popen("git rev-parse --git-dir --is-inside-work-tree --show-cdup 2>/dev/null", "r"),
4825 "=", read_repo_info);
4826 }
4827
4828 static int
4829 read_properties(FILE *pipe, const char *separators,
4830 int (*read_property)(char *, size_t, char *, size_t))
4831 {
4832 char buffer[BUFSIZ];
4833 char *name;
4834 int state = OK;
4835
4836 if (!pipe)
4837 return ERR;
4838
4839 while (state == OK && (name = fgets(buffer, sizeof(buffer), pipe))) {
4840 char *value;
4841 size_t namelen;
4842 size_t valuelen;
4843
4844 name = chomp_string(name);
4845 namelen = strcspn(name, separators);
4846
4847 if (name[namelen]) {
4848 name[namelen] = 0;
4849 value = chomp_string(name + namelen + 1);
4850 valuelen = strlen(value);
4851
4852 } else {
4853 value = "";
4854 valuelen = 0;
4855 }
4856
4857 state = read_property(name, namelen, value, valuelen);
4858 }
4859
4860 if (state != ERR && ferror(pipe))
4861 state = ERR;
4862
4863 pclose(pipe);
4864
4865 return state;
4866 }
4867
4868
4869 /*
4870 * Main
4871 */
4872
4873 static void __NORETURN
4874 quit(int sig)
4875 {
4876 /* XXX: Restore tty modes and let the OS cleanup the rest! */
4877 if (cursed)
4878 endwin();
4879 exit(0);
4880 }
4881
4882 static void __NORETURN
4883 die(const char *err, ...)
4884 {
4885 va_list args;
4886
4887 endwin();
4888
4889 va_start(args, err);
4890 fputs("tig: ", stderr);
4891 vfprintf(stderr, err, args);
4892 fputs("\n", stderr);
4893 va_end(args);
4894
4895 exit(1);
4896 }
4897
4898 int
4899 main(int argc, char *argv[])
4900 {
4901 struct view *view;
4902 enum request request;
4903 size_t i;
4904
4905 signal(SIGINT, quit);
4906
4907 if (setlocale(LC_ALL, "")) {
4908 char *codeset = nl_langinfo(CODESET);
4909
4910 string_ncopy(opt_codeset, codeset, strlen(codeset));
4911 }
4912
4913 if (load_repo_info() == ERR)
4914 die("Failed to load repo info.");
4915
4916 if (load_options() == ERR)
4917 die("Failed to load user config.");
4918
4919 /* Load the repo config file so options can be overwritten from
4920 * the command line. */
4921 if (load_repo_config() == ERR)
4922 die("Failed to load repo config.");
4923
4924 if (!parse_options(argc, argv))
4925 return 0;
4926
4927 /* Require a git repository unless when running in pager mode. */
4928 if (!opt_git_dir[0])
4929 die("Not a git repository");
4930
4931 if (*opt_codeset && strcmp(opt_codeset, opt_encoding)) {
4932 opt_iconv = iconv_open(opt_codeset, opt_encoding);
4933 if (opt_iconv == ICONV_NONE)
4934 die("Failed to initialize character set conversion");
4935 }
4936
4937 if (load_refs() == ERR)
4938 die("Failed to load refs.");
4939
4940 for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
4941 view->cmd_env = getenv(view->cmd_env);
4942
4943 request = opt_request;
4944
4945 init_display();
4946
4947 while (view_driver(display[current_view], request)) {
4948 int key;
4949 int i;
4950
4951 foreach_view (view, i)
4952 update_view(view);
4953
4954 /* Refresh, accept single keystroke of input */
4955 key = wgetch(status_win);
4956
4957 /* wgetch() with nodelay() enabled returns ERR when there's no
4958 * input. */
4959 if (key == ERR) {
4960 request = REQ_NONE;
4961 continue;
4962 }
4963
4964 request = get_keybinding(display[current_view]->keymap, key);
4965
4966 /* Some low-level request handling. This keeps access to
4967 * status_win restricted. */
4968 switch (request) {
4969 case REQ_PROMPT:
4970 {
4971 char *cmd = read_prompt(":");
4972
4973 if (cmd && string_format(opt_cmd, "git %s", cmd)) {
4974 if (strncmp(cmd, "show", 4) && isspace(cmd[4])) {
4975 opt_request = REQ_VIEW_DIFF;
4976 } else {
4977 opt_request = REQ_VIEW_PAGER;
4978 }
4979 break;
4980 }
4981
4982 request = REQ_NONE;
4983 break;
4984 }
4985 case REQ_SEARCH:
4986 case REQ_SEARCH_BACK:
4987 {
4988 const char *prompt = request == REQ_SEARCH
4989 ? "/" : "?";
4990 char *search = read_prompt(prompt);
4991
4992 if (search)
4993 string_ncopy(opt_search, search, strlen(search));
4994 else
4995 request = REQ_NONE;
4996 break;
4997 }
4998 case REQ_SCREEN_RESIZE:
4999 {
5000 int height, width;
5001
5002 getmaxyx(stdscr, height, width);
5003
5004 /* Resize the status view and let the view driver take
5005 * care of resizing the displayed views. */
5006 wresize(status_win, 1, width);
5007 mvwin(status_win, height - 1, 0);
5008 wrefresh(status_win);
5009 break;
5010 }
5011 default:
5012 break;
5013 }
5014 }
5015
5016 quit(0);
5017
5018 return 0;
5019 }
Full-screen terminal Git browser.