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