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