~mdw / tig / blob
? search:


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