~mdw / tig / blob
? search:


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