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