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