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