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