![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
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 */
14 #ifndef VERSION
15 #define VERSION "tig-0.3"
16 #endif
18 #ifndef DEBUG
19 #define NDEBUG
20 #endif
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 <unistd.h>
31 #include <time.h>
33 #include <curses.h>
35 #if __GNUC__ >= 3
36 #define __NORETURN __attribute__((__noreturn__))
37 #else
38 #define __NORETURN
39 #endif
41 static void __NORETURN die(const char *err, ...);
42 static void report(const char *msg, ...);
43 static int read_properties(FILE *pipe, const char *separators, int (*read)(char *, int, char *, int));
44 static void set_nonblocking_input(bool loading);
45 static size_t utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed);
47 #define ABS(x) ((x) >= 0 ? (x) : -(x))
48 #define MIN(x, y) ((x) < (y) ? (x) : (y))
50 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
51 #define STRING_SIZE(x) (sizeof(x) - 1)
53 #define SIZEOF_REF 256 /* Size of symbolic or SHA1 ID. */
54 #define SIZEOF_CMD 1024 /* Size of command buffer. */
55 #define SIZEOF_REVGRAPH 19 /* Size of revision ancestry graphics. */
57 /* This color name can be used to refer to the default term colors. */
58 #define COLOR_DEFAULT (-1)
60 /* The format and size of the date column in the main view. */
61 #define DATE_FORMAT "%Y-%m-%d %H:%M"
62 #define DATE_COLS STRING_SIZE("2006-04-29 14:21 ")
64 #define AUTHOR_COLS 20
66 /* The default interval between line numbers. */
67 #define NUMBER_INTERVAL 1
69 #define TABSIZE 8
71 #define SCALE_SPLIT_VIEW(height) ((height) * 2 / 3)
73 #define TIG_LS_REMOTE \
74 "git ls-remote . 2>/dev/null"
76 #define TIG_DIFF_CMD \
77 "git show --patch-with-stat --find-copies-harder -B -C %s"
79 #define TIG_LOG_CMD \
80 "git log --cc --stat -n100 %s"
82 #define TIG_MAIN_CMD \
83 "git log --topo-order --stat --pretty=raw %s"
85 /* XXX: Needs to be defined to the empty string. */
86 #define TIG_HELP_CMD ""
87 #define TIG_PAGER_CMD ""
89 /* Some ascii-shorthands fitted into the ncurses namespace. */
90 #define KEY_TAB '\t'
91 #define KEY_RETURN '\r'
92 #define KEY_ESC 27
95 struct ref {
96 char *name; /* Ref name; tag or head names are shortened. */
97 char id[41]; /* Commit SHA1 ID */
98 unsigned int tag:1; /* Is it a tag? */
99 unsigned int next:1; /* For ref lists: are there more refs? */
100 };
102 static struct ref **get_refs(char *id);
104 struct int_map {
105 const char *name;
106 int namelen;
107 int value;
108 };
110 static int
111 set_from_int_map(struct int_map *map, size_t map_size,
112 int *value, const char *name, int namelen)
113 {
115 int i;
117 for (i = 0; i < map_size; i++)
118 if (namelen == map[i].namelen &&
119 !strncasecmp(name, map[i].name, namelen)) {
120 *value = map[i].value;
121 return OK;
122 }
124 return ERR;
125 }
128 /*
129 * String helpers
130 */
132 static inline void
133 string_ncopy(char *dst, const char *src, int dstlen)
134 {
135 strncpy(dst, src, dstlen - 1);
136 dst[dstlen - 1] = 0;
138 }
140 /* Shorthand for safely copying into a fixed buffer. */
141 #define string_copy(dst, src) \
142 string_ncopy(dst, src, sizeof(dst))
144 static char *
145 chomp_string(char *name)
146 {
147 int namelen;
149 while (isspace(*name))
150 name++;
152 namelen = strlen(name) - 1;
153 while (namelen > 0 && isspace(name[namelen]))
154 name[namelen--] = 0;
156 return name;
157 }
159 static bool
160 string_nformat(char *buf, size_t bufsize, int *bufpos, const char *fmt, ...)
161 {
162 va_list args;
163 int pos = bufpos ? *bufpos : 0;
165 va_start(args, fmt);
166 pos += vsnprintf(buf + pos, bufsize - pos, fmt, args);
167 va_end(args);
169 if (bufpos)
170 *bufpos = pos;
172 return pos >= bufsize ? FALSE : TRUE;
173 }
175 #define string_format(buf, fmt, args...) \
176 string_nformat(buf, sizeof(buf), NULL, fmt, args)
178 #define string_format_from(buf, from, fmt, args...) \
179 string_nformat(buf, sizeof(buf), from, fmt, args)
181 static int
182 string_enum_compare(const char *str1, const char *str2, int len)
183 {
184 size_t i;
186 #define string_enum_sep(x) ((x) == '-' || (x) == '_' || (x) == '.')
188 /* Diff-Header == DIFF_HEADER */
189 for (i = 0; i < len; i++) {
190 if (toupper(str1[i]) == toupper(str2[i]))
191 continue;
193 if (string_enum_sep(str1[i]) &&
194 string_enum_sep(str2[i]))
195 continue;
197 return str1[i] - str2[i];
198 }
200 return 0;
201 }
203 /* Shell quoting
204 *
205 * NOTE: The following is a slightly modified copy of the git project's shell
206 * quoting routines found in the quote.c file.
207 *
208 * Help to copy the thing properly quoted for the shell safety. any single
209 * quote is replaced with '\'', any exclamation point is replaced with '\!',
210 * and the whole thing is enclosed in a
211 *
212 * E.g.
213 * original sq_quote result
214 * name ==> name ==> 'name'
215 * a b ==> a b ==> 'a b'
216 * a'b ==> a'\''b ==> 'a'\''b'
217 * a!b ==> a'\!'b ==> 'a'\!'b'
218 */
220 static size_t
221 sq_quote(char buf[SIZEOF_CMD], size_t bufsize, const char *src)
222 {
223 char c;
225 #define BUFPUT(x) do { if (bufsize < SIZEOF_CMD) buf[bufsize++] = (x); } while (0)
227 BUFPUT('\'');
228 while ((c = *src++)) {
229 if (c == '\'' || c == '!') {
230 BUFPUT('\'');
231 BUFPUT('\\');
232 BUFPUT(c);
233 BUFPUT('\'');
234 } else {
235 BUFPUT(c);
236 }
237 }
238 BUFPUT('\'');
240 return bufsize;
241 }
244 /*
245 * User requests
246 */
248 #define REQ_INFO \
249 /* XXX: Keep the view request first and in sync with views[]. */ \
250 REQ_GROUP("View switching") \
251 REQ_(VIEW_MAIN, "Show main view"), \
252 REQ_(VIEW_DIFF, "Show diff view"), \
253 REQ_(VIEW_LOG, "Show log view"), \
254 REQ_(VIEW_HELP, "Show help page"), \
255 REQ_(VIEW_PAGER, "Show pager view"), \
256 \
257 REQ_GROUP("View manipulation") \
258 REQ_(ENTER, "Enter current line and scroll"), \
259 REQ_(NEXT, "Move to next"), \
260 REQ_(PREVIOUS, "Move to previous"), \
261 REQ_(VIEW_NEXT, "Move focus to next view"), \
262 REQ_(VIEW_CLOSE, "Close the current view"), \
263 REQ_(QUIT, "Close all views and quit"), \
264 \
265 REQ_GROUP("Cursor navigation") \
266 REQ_(MOVE_UP, "Move cursor one line up"), \
267 REQ_(MOVE_DOWN, "Move cursor one line down"), \
268 REQ_(MOVE_PAGE_DOWN, "Move cursor one page down"), \
269 REQ_(MOVE_PAGE_UP, "Move cursor one page up"), \
270 REQ_(MOVE_FIRST_LINE, "Move cursor to first line"), \
271 REQ_(MOVE_LAST_LINE, "Move cursor to last line"), \
272 \
273 REQ_GROUP("Scrolling") \
274 REQ_(SCROLL_LINE_UP, "Scroll one line up"), \
275 REQ_(SCROLL_LINE_DOWN, "Scroll one line down"), \
276 REQ_(SCROLL_PAGE_UP, "Scroll one page up"), \
277 REQ_(SCROLL_PAGE_DOWN, "Scroll one page down"), \
278 \
279 REQ_GROUP("Misc") \
280 REQ_(PROMPT, "Bring up the prompt"), \
281 REQ_(SCREEN_UPDATE, "Update the screen"), \
282 REQ_(SCREEN_REDRAW, "Redraw the screen"), \
283 REQ_(SCREEN_RESIZE, "Resize the screen"), \
284 REQ_(SHOW_VERSION, "Show version information"), \
285 REQ_(STOP_LOADING, "Stop all loading views"), \
286 REQ_(TOGGLE_LINENO, "Toggle line numbers"), \
287 REQ_(TOGGLE_REV_GRAPH, "Toggle revision graph visualization")
290 /* User action requests. */
291 enum request {
292 #define REQ_GROUP(help)
293 #define REQ_(req, help) REQ_##req
295 /* Offset all requests to avoid conflicts with ncurses getch values. */
296 REQ_OFFSET = KEY_MAX + 1,
297 REQ_INFO,
298 REQ_UNKNOWN,
300 #undef REQ_GROUP
301 #undef REQ_
302 };
304 struct request_info {
305 enum request request;
306 char *name;
307 int namelen;
308 char *help;
309 };
311 static struct request_info req_info[] = {
312 #define REQ_GROUP(help) { 0, NULL, 0, (help) },
313 #define REQ_(req, help) { REQ_##req, (#req), STRING_SIZE(#req), (help) }
314 REQ_INFO
315 #undef REQ_GROUP
316 #undef REQ_
317 };
319 static enum request
320 get_request(const char *name)
321 {
322 int namelen = strlen(name);
323 int i;
325 for (i = 0; i < ARRAY_SIZE(req_info); i++)
326 if (req_info[i].namelen == namelen &&
327 !string_enum_compare(req_info[i].name, name, namelen))
328 return req_info[i].request;
330 return REQ_UNKNOWN;
331 }
334 /*
335 * Options
336 */
338 static const char usage[] =
339 VERSION " (" __DATE__ ")\n"
340 "\n"
341 "Usage: tig [options]\n"
342 " or: tig [options] [--] [git log options]\n"
343 " or: tig [options] log [git log options]\n"
344 " or: tig [options] diff [git diff options]\n"
345 " or: tig [options] show [git show options]\n"
346 " or: tig [options] < [git command output]\n"
347 "\n"
348 "Options:\n"
349 " -l Start up in log view\n"
350 " -d Start up in diff view\n"
351 " -n[I], --line-number[=I] Show line numbers with given interval\n"
352 " -b[N], --tab-size[=N] Set number of spaces for tab expansion\n"
353 " -- Mark end of tig options\n"
354 " -v, --version Show version and exit\n"
355 " -h, --help Show help message and exit\n";
357 /* Option and state variables. */
358 static bool opt_line_number = FALSE;
359 static bool opt_rev_graph = TRUE;
360 static int opt_num_interval = NUMBER_INTERVAL;
361 static int opt_tab_size = TABSIZE;
362 static enum request opt_request = REQ_VIEW_MAIN;
363 static char opt_cmd[SIZEOF_CMD] = "";
364 static char opt_encoding[20] = "";
365 static bool opt_utf8 = TRUE;
366 static FILE *opt_pipe = NULL;
368 enum option_type {
369 OPT_NONE,
370 OPT_INT,
371 };
373 static bool
374 check_option(char *opt, char short_name, char *name, enum option_type type, ...)
375 {
376 va_list args;
377 char *value = "";
378 int *number;
380 if (opt[0] != '-')
381 return FALSE;
383 if (opt[1] == '-') {
384 int namelen = strlen(name);
386 opt += 2;
388 if (strncmp(opt, name, namelen))
389 return FALSE;
391 if (opt[namelen] == '=')
392 value = opt + namelen + 1;
394 } else {
395 if (!short_name || opt[1] != short_name)
396 return FALSE;
397 value = opt + 2;
398 }
400 va_start(args, type);
401 if (type == OPT_INT) {
402 number = va_arg(args, int *);
403 if (isdigit(*value))
404 *number = atoi(value);
405 }
406 va_end(args);
408 return TRUE;
409 }
411 /* Returns the index of log or diff command or -1 to exit. */
412 static bool
413 parse_options(int argc, char *argv[])
414 {
415 int i;
417 for (i = 1; i < argc; i++) {
418 char *opt = argv[i];
420 if (!strcmp(opt, "-l")) {
421 opt_request = REQ_VIEW_LOG;
422 continue;
423 }
425 if (!strcmp(opt, "-d")) {
426 opt_request = REQ_VIEW_DIFF;
427 continue;
428 }
430 if (check_option(opt, 'n', "line-number", OPT_INT, &opt_num_interval)) {
431 opt_line_number = TRUE;
432 continue;
433 }
435 if (check_option(opt, 'b', "tab-size", OPT_INT, &opt_tab_size)) {
436 opt_tab_size = MIN(opt_tab_size, TABSIZE);
437 continue;
438 }
440 if (check_option(opt, 'v', "version", OPT_NONE)) {
441 printf("tig version %s\n", VERSION);
442 return FALSE;
443 }
445 if (check_option(opt, 'h', "help", OPT_NONE)) {
446 printf(usage);
447 return FALSE;
448 }
450 if (!strcmp(opt, "--")) {
451 i++;
452 break;
453 }
455 if (!strcmp(opt, "log") ||
456 !strcmp(opt, "diff") ||
457 !strcmp(opt, "show")) {
458 opt_request = opt[0] == 'l'
459 ? REQ_VIEW_LOG : REQ_VIEW_DIFF;
460 break;
461 }
463 if (opt[0] && opt[0] != '-')
464 break;
466 die("unknown option '%s'\n\n%s", opt, usage);
467 }
469 if (!isatty(STDIN_FILENO)) {
470 opt_request = REQ_VIEW_PAGER;
471 opt_pipe = stdin;
473 } else if (i < argc) {
474 size_t buf_size;
476 if (opt_request == REQ_VIEW_MAIN)
477 /* XXX: This is vulnerable to the user overriding
478 * options required for the main view parser. */
479 string_copy(opt_cmd, "git log --stat --pretty=raw");
480 else
481 string_copy(opt_cmd, "git");
482 buf_size = strlen(opt_cmd);
484 while (buf_size < sizeof(opt_cmd) && i < argc) {
485 opt_cmd[buf_size++] = ' ';
486 buf_size = sq_quote(opt_cmd, buf_size, argv[i++]);
487 }
489 if (buf_size >= sizeof(opt_cmd))
490 die("command too long");
492 opt_cmd[buf_size] = 0;
494 }
496 if (*opt_encoding && strcasecmp(opt_encoding, "UTF-8"))
497 opt_utf8 = FALSE;
499 return TRUE;
500 }
503 /*
504 * Line-oriented content detection.
505 */
507 #define LINE_INFO \
508 LINE(DIFF_HEADER, "diff --git ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
509 LINE(DIFF_CHUNK, "@@", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
510 LINE(DIFF_ADD, "+", COLOR_GREEN, COLOR_DEFAULT, 0), \
511 LINE(DIFF_DEL, "-", COLOR_RED, COLOR_DEFAULT, 0), \
512 LINE(DIFF_INDEX, "index ", COLOR_BLUE, COLOR_DEFAULT, 0), \
513 LINE(DIFF_OLDMODE, "old file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
514 LINE(DIFF_NEWMODE, "new file mode ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
515 LINE(DIFF_COPY_FROM, "copy from", COLOR_YELLOW, COLOR_DEFAULT, 0), \
516 LINE(DIFF_COPY_TO, "copy to", COLOR_YELLOW, COLOR_DEFAULT, 0), \
517 LINE(DIFF_RENAME_FROM, "rename from", COLOR_YELLOW, COLOR_DEFAULT, 0), \
518 LINE(DIFF_RENAME_TO, "rename to", COLOR_YELLOW, COLOR_DEFAULT, 0), \
519 LINE(DIFF_SIMILARITY, "similarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
520 LINE(DIFF_DISSIMILARITY,"dissimilarity ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
521 LINE(DIFF_TREE, "diff-tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
522 LINE(PP_AUTHOR, "Author: ", COLOR_CYAN, COLOR_DEFAULT, 0), \
523 LINE(PP_COMMIT, "Commit: ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
524 LINE(PP_MERGE, "Merge: ", COLOR_BLUE, COLOR_DEFAULT, 0), \
525 LINE(PP_DATE, "Date: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
526 LINE(PP_ADATE, "AuthorDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
527 LINE(PP_CDATE, "CommitDate: ", COLOR_YELLOW, COLOR_DEFAULT, 0), \
528 LINE(PP_REFS, "Refs: ", COLOR_RED, COLOR_DEFAULT, 0), \
529 LINE(COMMIT, "commit ", COLOR_GREEN, COLOR_DEFAULT, 0), \
530 LINE(PARENT, "parent ", COLOR_BLUE, COLOR_DEFAULT, 0), \
531 LINE(TREE, "tree ", COLOR_BLUE, COLOR_DEFAULT, 0), \
532 LINE(AUTHOR, "author ", COLOR_CYAN, COLOR_DEFAULT, 0), \
533 LINE(COMMITTER, "committer ", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
534 LINE(SIGNOFF, " Signed-off-by", COLOR_YELLOW, COLOR_DEFAULT, 0), \
535 LINE(DEFAULT, "", COLOR_DEFAULT, COLOR_DEFAULT, A_NORMAL), \
536 LINE(CURSOR, "", COLOR_WHITE, COLOR_GREEN, A_BOLD), \
537 LINE(STATUS, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
538 LINE(TITLE_BLUR, "", COLOR_WHITE, COLOR_BLUE, 0), \
539 LINE(TITLE_FOCUS, "", COLOR_WHITE, COLOR_BLUE, A_BOLD), \
540 LINE(MAIN_DATE, "", COLOR_BLUE, COLOR_DEFAULT, 0), \
541 LINE(MAIN_AUTHOR, "", COLOR_GREEN, COLOR_DEFAULT, 0), \
542 LINE(MAIN_COMMIT, "", COLOR_DEFAULT, COLOR_DEFAULT, 0), \
543 LINE(MAIN_DELIM, "", COLOR_MAGENTA, COLOR_DEFAULT, 0), \
544 LINE(MAIN_TAG, "", COLOR_MAGENTA, COLOR_DEFAULT, A_BOLD), \
545 LINE(MAIN_REF, "", COLOR_CYAN, COLOR_DEFAULT, A_BOLD), \
547 enum line_type {
548 #define LINE(type, line, fg, bg, attr) \
549 LINE_##type
550 LINE_INFO
551 #undef LINE
552 };
554 struct line_info {
555 const char *name; /* Option name. */
556 int namelen; /* Size of option name. */
557 const char *line; /* The start of line to match. */
558 int linelen; /* Size of string to match. */
559 int fg, bg, attr; /* Color and text attributes for the lines. */
560 };
562 static struct line_info line_info[] = {
563 #define LINE(type, line, fg, bg, attr) \
564 { #type, STRING_SIZE(#type), (line), STRING_SIZE(line), (fg), (bg), (attr) }
565 LINE_INFO
566 #undef LINE
567 };
569 static enum line_type
570 get_line_type(char *line)
571 {
572 int linelen = strlen(line);
573 enum line_type type;
575 for (type = 0; type < ARRAY_SIZE(line_info); type++)
576 /* Case insensitive search matches Signed-off-by lines better. */
577 if (linelen >= line_info[type].linelen &&
578 !strncasecmp(line_info[type].line, line, line_info[type].linelen))
579 return type;
581 return LINE_DEFAULT;
582 }
584 static inline int
585 get_line_attr(enum line_type type)
586 {
587 assert(type < ARRAY_SIZE(line_info));
588 return COLOR_PAIR(type) | line_info[type].attr;
589 }
591 static struct line_info *
592 get_line_info(char *name, int namelen)
593 {
594 enum line_type type;
596 for (type = 0; type < ARRAY_SIZE(line_info); type++)
597 if (namelen == line_info[type].namelen &&
598 !string_enum_compare(line_info[type].name, name, namelen))
599 return &line_info[type];
601 return NULL;
602 }
604 static void
605 init_colors(void)
606 {
607 int default_bg = COLOR_BLACK;
608 int default_fg = COLOR_WHITE;
609 enum line_type type;
611 start_color();
613 if (use_default_colors() != ERR) {
614 default_bg = -1;
615 default_fg = -1;
616 }
618 for (type = 0; type < ARRAY_SIZE(line_info); type++) {
619 struct line_info *info = &line_info[type];
620 int bg = info->bg == COLOR_DEFAULT ? default_bg : info->bg;
621 int fg = info->fg == COLOR_DEFAULT ? default_fg : info->fg;
623 init_pair(type, fg, bg);
624 }
625 }
627 struct line {
628 enum line_type type;
629 void *data; /* User data */
630 };
633 /*
634 * Keys
635 */
637 struct keybinding {
638 int alias;
639 enum request request;
640 struct keybinding *next;
641 };
643 static struct keybinding default_keybindings[] = {
644 /* View switching */
645 { 'm', REQ_VIEW_MAIN },
646 { 'd', REQ_VIEW_DIFF },
647 { 'l', REQ_VIEW_LOG },
648 { 'p', REQ_VIEW_PAGER },
649 { 'h', REQ_VIEW_HELP },
650 { '?', REQ_VIEW_HELP },
652 /* View manipulation */
653 { 'q', REQ_VIEW_CLOSE },
654 { KEY_TAB, REQ_VIEW_NEXT },
655 { KEY_RETURN, REQ_ENTER },
656 { KEY_UP, REQ_PREVIOUS },
657 { KEY_DOWN, REQ_NEXT },
659 /* Cursor navigation */
660 { 'k', REQ_MOVE_UP },
661 { 'j', REQ_MOVE_DOWN },
662 { KEY_HOME, REQ_MOVE_FIRST_LINE },
663 { KEY_END, REQ_MOVE_LAST_LINE },
664 { KEY_NPAGE, REQ_MOVE_PAGE_DOWN },
665 { ' ', REQ_MOVE_PAGE_DOWN },
666 { KEY_PPAGE, REQ_MOVE_PAGE_UP },
667 { 'b', REQ_MOVE_PAGE_UP },
668 { '-', REQ_MOVE_PAGE_UP },
670 /* Scrolling */
671 { KEY_IC, REQ_SCROLL_LINE_UP },
672 { KEY_DC, REQ_SCROLL_LINE_DOWN },
673 { 'w', REQ_SCROLL_PAGE_UP },
674 { 's', REQ_SCROLL_PAGE_DOWN },
676 /* Misc */
677 { 'Q', REQ_QUIT },
678 { 'z', REQ_STOP_LOADING },
679 { 'v', REQ_SHOW_VERSION },
680 { 'r', REQ_SCREEN_REDRAW },
681 { 'n', REQ_TOGGLE_LINENO },
682 { 'g', REQ_TOGGLE_REV_GRAPH},
683 { ':', REQ_PROMPT },
685 /* wgetch() with nodelay() enabled returns ERR when there's no input. */
686 { ERR, REQ_SCREEN_UPDATE },
688 /* Use the ncurses SIGWINCH handler. */
689 { KEY_RESIZE, REQ_SCREEN_RESIZE },
690 };
692 #define KEYMAP_INFO \
693 KEYMAP_(GENERIC), \
694 KEYMAP_(MAIN), \
695 KEYMAP_(DIFF), \
696 KEYMAP_(LOG), \
697 KEYMAP_(PAGER), \
698 KEYMAP_(HELP) \
700 enum keymap {
701 #define KEYMAP_(name) KEYMAP_##name
702 KEYMAP_INFO
703 #undef KEYMAP_
704 };
706 static struct int_map keymap_table[] = {
707 #define KEYMAP_(name) { #name, STRING_SIZE(#name), KEYMAP_##name }
708 KEYMAP_INFO
709 #undef KEYMAP_
710 };
712 #define set_keymap(map, name) \
713 set_from_int_map(keymap_table, ARRAY_SIZE(keymap_table), map, name, strlen(name))
715 static struct keybinding *keybindings[ARRAY_SIZE(keymap_table)];
717 static void
718 add_keybinding(enum keymap keymap, enum request request, int key)
719 {
720 struct keybinding *keybinding;
722 keybinding = calloc(1, sizeof(*keybinding));
723 if (!keybinding)
724 die("Failed to allocate keybinding");
726 keybinding->alias = key;
727 keybinding->request = request;
728 keybinding->next = keybindings[keymap];
729 keybindings[keymap] = keybinding;
730 }
732 /* Looks for a key binding first in the given map, then in the generic map, and
733 * lastly in the default keybindings. */
734 static enum request
735 get_keybinding(enum keymap keymap, int key)
736 {
737 struct keybinding *kbd;
738 int i;
740 for (kbd = keybindings[keymap]; kbd; kbd = kbd->next)
741 if (kbd->alias == key)
742 return kbd->request;
744 for (kbd = keybindings[KEYMAP_GENERIC]; kbd; kbd = kbd->next)
745 if (kbd->alias == key)
746 return kbd->request;
748 for (i = 0; i < ARRAY_SIZE(default_keybindings); i++)
749 if (default_keybindings[i].alias == key)
750 return default_keybindings[i].request;
752 return (enum request) key;
753 }
756 struct key {
757 char *name;
758 int value;
759 };
761 static struct key key_table[] = {
762 { "Enter", KEY_RETURN },
763 { "Space", ' ' },
764 { "Backspace", KEY_BACKSPACE },
765 { "Tab", KEY_TAB },
766 { "Escape", KEY_ESC },
767 { "Left", KEY_LEFT },
768 { "Right", KEY_RIGHT },
769 { "Up", KEY_UP },
770 { "Down", KEY_DOWN },
771 { "Insert", KEY_IC },
772 { "Delete", KEY_DC },
773 { "Home", KEY_HOME },
774 { "End", KEY_END },
775 { "PageUp", KEY_PPAGE },
776 { "PageDown", KEY_NPAGE },
777 { "F1", KEY_F(1) },
778 { "F2", KEY_F(2) },
779 { "F3", KEY_F(3) },
780 { "F4", KEY_F(4) },
781 { "F5", KEY_F(5) },
782 { "F6", KEY_F(6) },
783 { "F7", KEY_F(7) },
784 { "F8", KEY_F(8) },
785 { "F9", KEY_F(9) },
786 { "F10", KEY_F(10) },
787 { "F11", KEY_F(11) },
788 { "F12", KEY_F(12) },
789 };
791 static int
792 get_key_value(const char *name)
793 {
794 int i;
796 for (i = 0; i < ARRAY_SIZE(key_table); i++)
797 if (!strcasecmp(key_table[i].name, name))
798 return key_table[i].value;
800 if (strlen(name) == 1 && isprint(*name))
801 return (int) *name;
803 return ERR;
804 }
806 static char *
807 get_key(enum request request)
808 {
809 static char buf[BUFSIZ];
810 static char key_char[] = "'X'";
811 int pos = 0;
812 char *sep = " ";
813 int i;
815 buf[pos] = 0;
817 for (i = 0; i < ARRAY_SIZE(default_keybindings); i++) {
818 struct keybinding *keybinding = &default_keybindings[i];
819 char *seq = NULL;
820 int key;
822 if (keybinding->request != request)
823 continue;
825 for (key = 0; key < ARRAY_SIZE(key_table); key++)
826 if (key_table[key].value == keybinding->alias)
827 seq = key_table[key].name;
829 if (seq == NULL &&
830 keybinding->alias < 127 &&
831 isprint(keybinding->alias)) {
832 key_char[1] = (char) keybinding->alias;
833 seq = key_char;
834 }
836 if (!seq)
837 seq = "'?'";
839 if (!string_format_from(buf, &pos, "%s%s", sep, seq))
840 return "Too many keybindings!";
841 sep = ", ";
842 }
844 return buf;
845 }
848 /*
849 * User config file handling.
850 */
852 static struct int_map color_map[] = {
853 #define COLOR_MAP(name) { #name, STRING_SIZE(#name), COLOR_##name }
854 COLOR_MAP(DEFAULT),
855 COLOR_MAP(BLACK),
856 COLOR_MAP(BLUE),
857 COLOR_MAP(CYAN),
858 COLOR_MAP(GREEN),
859 COLOR_MAP(MAGENTA),
860 COLOR_MAP(RED),
861 COLOR_MAP(WHITE),
862 COLOR_MAP(YELLOW),
863 };
865 #define set_color(color, name) \
866 set_from_int_map(color_map, ARRAY_SIZE(color_map), color, name, strlen(name))
868 static struct int_map attr_map[] = {
869 #define ATTR_MAP(name) { #name, STRING_SIZE(#name), A_##name }
870 ATTR_MAP(NORMAL),
871 ATTR_MAP(BLINK),
872 ATTR_MAP(BOLD),
873 ATTR_MAP(DIM),
874 ATTR_MAP(REVERSE),
875 ATTR_MAP(STANDOUT),
876 ATTR_MAP(UNDERLINE),
877 };
879 #define set_attribute(attr, name) \
880 set_from_int_map(attr_map, ARRAY_SIZE(attr_map), attr, name, strlen(name))
882 static int config_lineno;
883 static bool config_errors;
884 static char *config_msg;
886 /* Wants: object fgcolor bgcolor [attr] */
887 static int
888 option_color_command(int argc, char *argv[])
889 {
890 struct line_info *info;
892 if (argc != 3 && argc != 4) {
893 config_msg = "Wrong number of arguments given to color command";
894 return ERR;
895 }
897 info = get_line_info(argv[0], strlen(argv[0]));
898 if (!info) {
899 config_msg = "Unknown color name";
900 return ERR;
901 }
903 if (set_color(&info->fg, argv[1]) == ERR) {
904 config_msg = "Unknown color";
905 return ERR;
906 }
908 if (set_color(&info->bg, argv[2]) == ERR) {
909 config_msg = "Unknown color";
910 return ERR;
911 }
913 if (argc == 4 && set_attribute(&info->attr, argv[3]) == ERR) {
914 config_msg = "Unknown attribute";
915 return ERR;
916 }
918 return OK;
919 }
921 /* Wants: name = value */
922 static int
923 option_set_command(int argc, char *argv[])
924 {
925 if (argc != 3) {
926 config_msg = "Wrong number of arguments given to set command";
927 return ERR;
928 }
930 if (strcmp(argv[1], "=")) {
931 config_msg = "No value assigned";
932 return ERR;
933 }
935 if (!strcmp(argv[0], "show-rev-graph")) {
936 opt_rev_graph = (!strcmp(argv[2], "1") ||
937 !strcmp(argv[2], "true") ||
938 !strcmp(argv[2], "yes"));
939 return OK;
940 }
942 if (!strcmp(argv[0], "line-number-interval")) {
943 opt_num_interval = atoi(argv[2]);
944 return OK;
945 }
947 if (!strcmp(argv[0], "tab-size")) {
948 opt_tab_size = atoi(argv[2]);
949 return OK;
950 }
952 if (!strcmp(argv[0], "encoding")) {
953 string_copy(opt_encoding, argv[2]);
954 return OK;
955 }
957 return ERR;
958 }
960 /* Wants: mode request key */
961 static int
962 option_bind_command(int argc, char *argv[])
963 {
964 enum request request;
965 int keymap;
966 int key;
968 if (argc != 3) {
969 config_msg = "Wrong number of arguments given to bind command";
970 return ERR;
971 }
973 if (set_keymap(&keymap, argv[0]) == ERR) {
974 config_msg = "Unknown key map";
975 return ERR;
976 }
978 key = get_key_value(argv[1]);
979 if (key == ERR) {
980 config_msg = "Unknown key";
981 return ERR;
982 }
984 request = get_request(argv[2]);
985 if (request == REQ_UNKNOWN) {
986 config_msg = "Unknown request name";
987 return ERR;
988 }
990 add_keybinding(keymap, request, key);
992 return OK;
993 }
995 static int
996 set_option(char *opt, char *value)
997 {
998 char *argv[16];
999 int valuelen;
1000 int argc = 0;
1002 /* Tokenize */
1003 while (argc < ARRAY_SIZE(argv) && (valuelen = strcspn(value, " \t"))) {
1004 argv[argc++] = value;
1006 value += valuelen;
1007 if (!*value)
1008 break;
1010 *value++ = 0;
1011 while (isspace(*value))
1012 value++;
1013 }
1015 if (!strcmp(opt, "color"))
1016 return option_color_command(argc, argv);
1018 if (!strcmp(opt, "set"))
1019 return option_set_command(argc, argv);
1021 if (!strcmp(opt, "bind"))
1022 return option_bind_command(argc, argv);
1024 return ERR;
1025 }
1027 static int
1028 read_option(char *opt, int optlen, char *value, int valuelen)
1029 {
1030 config_lineno++;
1031 config_msg = "Internal error";
1033 optlen = strcspn(opt, "#;");
1034 if (optlen == 0) {
1035 /* The whole line is a commend or empty. */
1036 return OK;
1038 } else if (opt[optlen] != 0) {
1039 /* Part of the option name is a comment, so the value part
1040 * should be ignored. */
1041 valuelen = 0;
1042 opt[optlen] = value[valuelen] = 0;
1043 } else {
1044 /* Else look for comment endings in the value. */
1045 valuelen = strcspn(value, "#;");
1046 value[valuelen] = 0;
1047 }
1049 if (set_option(opt, value) == ERR) {
1050 fprintf(stderr, "Error on line %d, near '%.*s' option: %s\n",
1051 config_lineno, optlen, opt, config_msg);
1052 config_errors = TRUE;
1053 }
1055 /* Always keep going if errors are encountered. */
1056 return OK;
1057 }
1059 static int
1060 load_options(void)
1061 {
1062 char *home = getenv("HOME");
1063 char buf[1024];
1064 FILE *file;
1066 config_lineno = 0;
1067 config_errors = FALSE;
1069 if (!home || !string_format(buf, "%s/.tigrc", home))
1070 return ERR;
1072 /* It's ok that the file doesn't exist. */
1073 file = fopen(buf, "r");
1074 if (!file)
1075 return OK;
1077 if (read_properties(file, " \t", read_option) == ERR ||
1078 config_errors == TRUE)
1079 fprintf(stderr, "Errors while loading %s.\n", buf);
1081 return OK;
1082 }
1085 /*
1086 * The viewer
1087 */
1089 struct view;
1090 struct view_ops;
1092 /* The display array of active views and the index of the current view. */
1093 static struct view *display[2];
1094 static unsigned int current_view;
1096 #define foreach_view(view, i) \
1097 for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
1099 #define displayed_views() (display[1] != NULL ? 2 : 1)
1101 /* Current head and commit ID */
1102 static char ref_commit[SIZEOF_REF] = "HEAD";
1103 static char ref_head[SIZEOF_REF] = "HEAD";
1105 struct view {
1106 const char *name; /* View name */
1107 const char *cmd_fmt; /* Default command line format */
1108 const char *cmd_env; /* Command line set via environment */
1109 const char *id; /* Points to either of ref_{head,commit} */
1111 struct view_ops *ops; /* View operations */
1113 enum keymap keymap; /* What keymap does this view have */
1115 char cmd[SIZEOF_CMD]; /* Command buffer */
1116 char ref[SIZEOF_REF]; /* Hovered commit reference */
1117 char vid[SIZEOF_REF]; /* View ID. Set to id member when updating. */
1119 int height, width; /* The width and height of the main window */
1120 WINDOW *win; /* The main window */
1121 WINDOW *title; /* The title window living below the main window */
1123 /* Navigation */
1124 unsigned long offset; /* Offset of the window top */
1125 unsigned long lineno; /* Current line number */
1127 /* If non-NULL, points to the view that opened this view. If this view
1128 * is closed tig will switch back to the parent view. */
1129 struct view *parent;
1131 /* Buffering */
1132 unsigned long lines; /* Total number of lines */
1133 struct line *line; /* Line index */
1134 unsigned long line_size;/* Total number of allocated lines */
1135 unsigned int digits; /* Number of digits in the lines member. */
1137 /* Loading */
1138 FILE *pipe;
1139 time_t start_time;
1140 };
1142 struct view_ops {
1143 /* What type of content being displayed. Used in the title bar. */
1144 const char *type;
1145 /* Draw one line; @lineno must be < view->height. */
1146 bool (*draw)(struct view *view, struct line *line, unsigned int lineno);
1147 /* Read one line; updates view->line. */
1148 bool (*read)(struct view *view, char *data);
1149 /* Depending on view, change display based on current line. */
1150 bool (*enter)(struct view *view, struct line *line);
1151 };
1153 static struct view_ops pager_ops;
1154 static struct view_ops main_ops;
1156 #define VIEW_STR(name, cmd, env, ref, ops, map) \
1157 { name, cmd, #env, ref, ops, map}
1159 #define VIEW_(id, name, ops, ref) \
1160 VIEW_STR(name, TIG_##id##_CMD, TIG_##id##_CMD, ref, ops, KEYMAP_##id)
1163 static struct view views[] = {
1164 VIEW_(MAIN, "main", &main_ops, ref_head),
1165 VIEW_(DIFF, "diff", &pager_ops, ref_commit),
1166 VIEW_(LOG, "log", &pager_ops, ref_head),
1167 VIEW_(HELP, "help", &pager_ops, "static"),
1168 VIEW_(PAGER, "pager", &pager_ops, "static"),
1169 };
1171 #define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
1174 static bool
1175 draw_view_line(struct view *view, unsigned int lineno)
1176 {
1177 if (view->offset + lineno >= view->lines)
1178 return FALSE;
1180 return view->ops->draw(view, &view->line[view->offset + lineno], lineno);
1181 }
1183 static void
1184 redraw_view_from(struct view *view, int lineno)
1185 {
1186 assert(0 <= lineno && lineno < view->height);
1188 for (; lineno < view->height; lineno++) {
1189 if (!draw_view_line(view, lineno))
1190 break;
1191 }
1193 redrawwin(view->win);
1194 wrefresh(view->win);
1195 }
1197 static void
1198 redraw_view(struct view *view)
1199 {
1200 wclear(view->win);
1201 redraw_view_from(view, 0);
1202 }
1205 static void
1206 update_view_title(struct view *view)
1207 {
1208 if (view == display[current_view])
1209 wbkgdset(view->title, get_line_attr(LINE_TITLE_FOCUS));
1210 else
1211 wbkgdset(view->title, get_line_attr(LINE_TITLE_BLUR));
1213 werase(view->title);
1214 wmove(view->title, 0, 0);
1216 if (*view->ref)
1217 wprintw(view->title, "[%s] %s", view->name, view->ref);
1218 else
1219 wprintw(view->title, "[%s]", view->name);
1221 if (view->lines || view->pipe) {
1222 unsigned int view_lines = view->offset + view->height;
1223 unsigned int lines = view->lines
1224 ? MIN(view_lines, view->lines) * 100 / view->lines
1225 : 0;
1227 wprintw(view->title, " - %s %d of %d (%d%%)",
1228 view->ops->type,
1229 view->lineno + 1,
1230 view->lines,
1231 lines);
1232 }
1234 if (view->pipe) {
1235 time_t secs = time(NULL) - view->start_time;
1237 /* Three git seconds are a long time ... */
1238 if (secs > 2)
1239 wprintw(view->title, " %lds", secs);
1240 }
1242 wmove(view->title, 0, view->width - 1);
1243 wrefresh(view->title);
1244 }
1246 static void
1247 resize_display(void)
1248 {
1249 int offset, i;
1250 struct view *base = display[0];
1251 struct view *view = display[1] ? display[1] : display[0];
1253 /* Setup window dimensions */
1255 getmaxyx(stdscr, base->height, base->width);
1257 /* Make room for the status window. */
1258 base->height -= 1;
1260 if (view != base) {
1261 /* Horizontal split. */
1262 view->width = base->width;
1263 view->height = SCALE_SPLIT_VIEW(base->height);
1264 base->height -= view->height;
1266 /* Make room for the title bar. */
1267 view->height -= 1;
1268 }
1270 /* Make room for the title bar. */
1271 base->height -= 1;
1273 offset = 0;
1275 foreach_view (view, i) {
1276 if (!view->win) {
1277 view->win = newwin(view->height, 0, offset, 0);
1278 if (!view->win)
1279 die("Failed to create %s view", view->name);
1281 scrollok(view->win, TRUE);
1283 view->title = newwin(1, 0, offset + view->height, 0);
1284 if (!view->title)
1285 die("Failed to create title window");
1287 } else {
1288 wresize(view->win, view->height, view->width);
1289 mvwin(view->win, offset, 0);
1290 mvwin(view->title, offset + view->height, 0);
1291 }
1293 offset += view->height + 1;
1294 }
1295 }
1297 static void
1298 redraw_display(void)
1299 {
1300 struct view *view;
1301 int i;
1303 foreach_view (view, i) {
1304 redraw_view(view);
1305 update_view_title(view);
1306 }
1307 }
1309 static void
1310 update_display_cursor(void)
1311 {
1312 struct view *view = display[current_view];
1314 /* Move the cursor to the right-most column of the cursor line.
1315 *
1316 * XXX: This could turn out to be a bit expensive, but it ensures that
1317 * the cursor does not jump around. */
1318 if (view->lines) {
1319 wmove(view->win, view->lineno - view->offset, view->width - 1);
1320 wrefresh(view->win);
1321 }
1322 }
1324 /*
1325 * Navigation
1326 */
1328 /* Scrolling backend */
1329 static void
1330 do_scroll_view(struct view *view, int lines, bool redraw)
1331 {
1332 /* The rendering expects the new offset. */
1333 view->offset += lines;
1335 assert(0 <= view->offset && view->offset < view->lines);
1336 assert(lines);
1338 /* Redraw the whole screen if scrolling is pointless. */
1339 if (view->height < ABS(lines)) {
1340 redraw_view(view);
1342 } else {
1343 int line = lines > 0 ? view->height - lines : 0;
1344 int end = line + ABS(lines);
1346 wscrl(view->win, lines);
1348 for (; line < end; line++) {
1349 if (!draw_view_line(view, line))
1350 break;
1351 }
1352 }
1354 /* Move current line into the view. */
1355 if (view->lineno < view->offset) {
1356 view->lineno = view->offset;
1357 draw_view_line(view, 0);
1359 } else if (view->lineno >= view->offset + view->height) {
1360 if (view->lineno == view->offset + view->height) {
1361 /* Clear the hidden line so it doesn't show if the view
1362 * is scrolled up. */
1363 wmove(view->win, view->height, 0);
1364 wclrtoeol(view->win);
1365 }
1366 view->lineno = view->offset + view->height - 1;
1367 draw_view_line(view, view->lineno - view->offset);
1368 }
1370 assert(view->offset <= view->lineno && view->lineno < view->lines);
1372 if (!redraw)
1373 return;
1375 redrawwin(view->win);
1376 wrefresh(view->win);
1377 report("");
1378 }
1380 /* Scroll frontend */
1381 static void
1382 scroll_view(struct view *view, enum request request)
1383 {
1384 int lines = 1;
1386 switch (request) {
1387 case REQ_SCROLL_PAGE_DOWN:
1388 lines = view->height;
1389 case REQ_SCROLL_LINE_DOWN:
1390 if (view->offset + lines > view->lines)
1391 lines = view->lines - view->offset;
1393 if (lines == 0 || view->offset + view->height >= view->lines) {
1394 report("Cannot scroll beyond the last line");
1395 return;
1396 }
1397 break;
1399 case REQ_SCROLL_PAGE_UP:
1400 lines = view->height;
1401 case REQ_SCROLL_LINE_UP:
1402 if (lines > view->offset)
1403 lines = view->offset;
1405 if (lines == 0) {
1406 report("Cannot scroll beyond the first line");
1407 return;
1408 }
1410 lines = -lines;
1411 break;
1413 default:
1414 die("request %d not handled in switch", request);
1415 }
1417 do_scroll_view(view, lines, TRUE);
1418 }
1420 /* Cursor moving */
1421 static void
1422 move_view(struct view *view, enum request request, bool redraw)
1423 {
1424 int steps;
1426 switch (request) {
1427 case REQ_MOVE_FIRST_LINE:
1428 steps = -view->lineno;
1429 break;
1431 case REQ_MOVE_LAST_LINE:
1432 steps = view->lines - view->lineno - 1;
1433 break;
1435 case REQ_MOVE_PAGE_UP:
1436 steps = view->height > view->lineno
1437 ? -view->lineno : -view->height;
1438 break;
1440 case REQ_MOVE_PAGE_DOWN:
1441 steps = view->lineno + view->height >= view->lines
1442 ? view->lines - view->lineno - 1 : view->height;
1443 break;
1445 case REQ_MOVE_UP:
1446 steps = -1;
1447 break;
1449 case REQ_MOVE_DOWN:
1450 steps = 1;
1451 break;
1453 default:
1454 die("request %d not handled in switch", request);
1455 }
1457 if (steps <= 0 && view->lineno == 0) {
1458 report("Cannot move beyond the first line");
1459 return;
1461 } else if (steps >= 0 && view->lineno + 1 >= view->lines) {
1462 report("Cannot move beyond the last line");
1463 return;
1464 }
1466 /* Move the current line */
1467 view->lineno += steps;
1468 assert(0 <= view->lineno && view->lineno < view->lines);
1470 /* Repaint the old "current" line if we be scrolling */
1471 if (ABS(steps) < view->height) {
1472 int prev_lineno = view->lineno - steps - view->offset;
1474 wmove(view->win, prev_lineno, 0);
1475 wclrtoeol(view->win);
1476 draw_view_line(view, prev_lineno);
1477 }
1479 /* Check whether the view needs to be scrolled */
1480 if (view->lineno < view->offset ||
1481 view->lineno >= view->offset + view->height) {
1482 if (steps < 0 && -steps > view->offset) {
1483 steps = -view->offset;
1485 } else if (steps > 0) {
1486 if (view->lineno == view->lines - 1 &&
1487 view->lines > view->height) {
1488 steps = view->lines - view->offset - 1;
1489 if (steps >= view->height)
1490 steps -= view->height - 1;
1491 }
1492 }
1494 do_scroll_view(view, steps, redraw);
1495 return;
1496 }
1498 /* Draw the current line */
1499 draw_view_line(view, view->lineno - view->offset);
1501 if (!redraw)
1502 return;
1504 redrawwin(view->win);
1505 wrefresh(view->win);
1506 report("");
1507 }
1510 /*
1511 * Incremental updating
1512 */
1514 static void
1515 end_update(struct view *view)
1516 {
1517 if (!view->pipe)
1518 return;
1519 set_nonblocking_input(FALSE);
1520 if (view->pipe == stdin)
1521 fclose(view->pipe);
1522 else
1523 pclose(view->pipe);
1524 view->pipe = NULL;
1525 }
1527 static bool
1528 begin_update(struct view *view)
1529 {
1530 const char *id = view->id;
1532 if (view->pipe)
1533 end_update(view);
1535 if (opt_cmd[0]) {
1536 string_copy(view->cmd, opt_cmd);
1537 opt_cmd[0] = 0;
1538 /* When running random commands, the view ref could have become
1539 * invalid so clear it. */
1540 view->ref[0] = 0;
1541 } else {
1542 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
1544 if (!string_format(view->cmd, format, id, id, id, id, id))
1545 return FALSE;
1546 }
1548 /* Special case for the pager view. */
1549 if (opt_pipe) {
1550 view->pipe = opt_pipe;
1551 opt_pipe = NULL;
1552 } else {
1553 view->pipe = popen(view->cmd, "r");
1554 }
1556 if (!view->pipe)
1557 return FALSE;
1559 set_nonblocking_input(TRUE);
1561 view->offset = 0;
1562 view->lines = 0;
1563 view->lineno = 0;
1564 string_copy(view->vid, id);
1566 if (view->line) {
1567 int i;
1569 for (i = 0; i < view->lines; i++)
1570 if (view->line[i].data)
1571 free(view->line[i].data);
1573 free(view->line);
1574 view->line = NULL;
1575 }
1577 view->start_time = time(NULL);
1579 return TRUE;
1580 }
1582 static struct line *
1583 realloc_lines(struct view *view, size_t line_size)
1584 {
1585 struct line *tmp = realloc(view->line, sizeof(*view->line) * line_size);
1587 if (!tmp)
1588 return NULL;
1590 view->line = tmp;
1591 view->line_size = line_size;
1592 return view->line;
1593 }
1595 static bool
1596 update_view(struct view *view)
1597 {
1598 char buffer[BUFSIZ];
1599 char *line;
1600 /* The number of lines to read. If too low it will cause too much
1601 * redrawing (and possible flickering), if too high responsiveness
1602 * will suffer. */
1603 unsigned long lines = view->height;
1604 int redraw_from = -1;
1606 if (!view->pipe)
1607 return TRUE;
1609 /* Only redraw if lines are visible. */
1610 if (view->offset + view->height >= view->lines)
1611 redraw_from = view->lines - view->offset;
1613 if (!realloc_lines(view, view->lines + lines))
1614 goto alloc_error;
1616 while ((line = fgets(buffer, sizeof(buffer), view->pipe))) {
1617 int linelen = strlen(line);
1619 if (linelen)
1620 line[linelen - 1] = 0;
1622 if (!view->ops->read(view, line))
1623 goto alloc_error;
1625 if (lines-- == 1)
1626 break;
1627 }
1629 {
1630 int digits;
1632 lines = view->lines;
1633 for (digits = 0; lines; digits++)
1634 lines /= 10;
1636 /* Keep the displayed view in sync with line number scaling. */
1637 if (digits != view->digits) {
1638 view->digits = digits;
1639 redraw_from = 0;
1640 }
1641 }
1643 if (redraw_from >= 0) {
1644 /* If this is an incremental update, redraw the previous line
1645 * since for commits some members could have changed when
1646 * loading the main view. */
1647 if (redraw_from > 0)
1648 redraw_from--;
1650 /* Incrementally draw avoids flickering. */
1651 redraw_view_from(view, redraw_from);
1652 }
1654 /* Update the title _after_ the redraw so that if the redraw picks up a
1655 * commit reference in view->ref it'll be available here. */
1656 update_view_title(view);
1658 if (ferror(view->pipe)) {
1659 report("Failed to read: %s", strerror(errno));
1660 goto end;
1662 } else if (feof(view->pipe)) {
1663 report("");
1664 goto end;
1665 }
1667 return TRUE;
1669 alloc_error:
1670 report("Allocation failure");
1672 end:
1673 end_update(view);
1674 return FALSE;
1675 }
1678 /*
1679 * View opening
1680 */
1682 static void open_help_view(struct view *view)
1683 {
1684 char buf[BUFSIZ];
1685 int lines = ARRAY_SIZE(req_info) + 2;
1686 int i;
1688 if (view->lines > 0)
1689 return;
1691 for (i = 0; i < ARRAY_SIZE(req_info); i++)
1692 if (!req_info[i].request)
1693 lines++;
1695 view->line = calloc(lines, sizeof(*view->line));
1696 if (!view->line) {
1697 report("Allocation failure");
1698 return;
1699 }
1701 view->ops->read(view, "Quick reference for tig keybindings:");
1703 for (i = 0; i < ARRAY_SIZE(req_info); i++) {
1704 char *key;
1706 if (!req_info[i].request) {
1707 view->ops->read(view, "");
1708 view->ops->read(view, req_info[i].help);
1709 continue;
1710 }
1712 key = get_key(req_info[i].request);
1713 if (!string_format(buf, "%-25s %s", key, req_info[i].help))
1714 continue;
1716 view->ops->read(view, buf);
1717 }
1718 }
1720 enum open_flags {
1721 OPEN_DEFAULT = 0, /* Use default view switching. */
1722 OPEN_SPLIT = 1, /* Split current view. */
1723 OPEN_BACKGROUNDED = 2, /* Backgrounded. */
1724 OPEN_RELOAD = 4, /* Reload view even if it is the current. */
1725 };
1727 static void
1728 open_view(struct view *prev, enum request request, enum open_flags flags)
1729 {
1730 bool backgrounded = !!(flags & OPEN_BACKGROUNDED);
1731 bool split = !!(flags & OPEN_SPLIT);
1732 bool reload = !!(flags & OPEN_RELOAD);
1733 struct view *view = VIEW(request);
1734 int nviews = displayed_views();
1735 struct view *base_view = display[0];
1737 if (view == prev && nviews == 1 && !reload) {
1738 report("Already in %s view", view->name);
1739 return;
1740 }
1742 if (view == VIEW(REQ_VIEW_HELP)) {
1743 open_help_view(view);
1745 } else if ((reload || strcmp(view->vid, view->id)) &&
1746 !begin_update(view)) {
1747 report("Failed to load %s view", view->name);
1748 return;
1749 }
1751 if (split) {
1752 display[1] = view;
1753 if (!backgrounded)
1754 current_view = 1;
1755 } else {
1756 /* Maximize the current view. */
1757 memset(display, 0, sizeof(display));
1758 current_view = 0;
1759 display[current_view] = view;
1760 }
1762 /* Resize the view when switching between split- and full-screen,
1763 * or when switching between two different full-screen views. */
1764 if (nviews != displayed_views() ||
1765 (nviews == 1 && base_view != display[0]))
1766 resize_display();
1768 if (split && prev->lineno - prev->offset >= prev->height) {
1769 /* Take the title line into account. */
1770 int lines = prev->lineno - prev->offset - prev->height + 1;
1772 /* Scroll the view that was split if the current line is
1773 * outside the new limited view. */
1774 do_scroll_view(prev, lines, TRUE);
1775 }
1777 if (prev && view != prev) {
1778 if (split && !backgrounded) {
1779 /* "Blur" the previous view. */
1780 update_view_title(prev);
1781 }
1783 view->parent = prev;
1784 }
1786 if (view->pipe && view->lines == 0) {
1787 /* Clear the old view and let the incremental updating refill
1788 * the screen. */
1789 wclear(view->win);
1790 report("");
1791 } else {
1792 redraw_view(view);
1793 report("");
1794 }
1796 /* If the view is backgrounded the above calls to report()
1797 * won't redraw the view title. */
1798 if (backgrounded)
1799 update_view_title(view);
1800 }
1803 /*
1804 * User request switch noodle
1805 */
1807 static int
1808 view_driver(struct view *view, enum request request)
1809 {
1810 int i;
1812 switch (request) {
1813 case REQ_MOVE_UP:
1814 case REQ_MOVE_DOWN:
1815 case REQ_MOVE_PAGE_UP:
1816 case REQ_MOVE_PAGE_DOWN:
1817 case REQ_MOVE_FIRST_LINE:
1818 case REQ_MOVE_LAST_LINE:
1819 move_view(view, request, TRUE);
1820 break;
1822 case REQ_SCROLL_LINE_DOWN:
1823 case REQ_SCROLL_LINE_UP:
1824 case REQ_SCROLL_PAGE_DOWN:
1825 case REQ_SCROLL_PAGE_UP:
1826 scroll_view(view, request);
1827 break;
1829 case REQ_VIEW_MAIN:
1830 case REQ_VIEW_DIFF:
1831 case REQ_VIEW_LOG:
1832 case REQ_VIEW_HELP:
1833 case REQ_VIEW_PAGER:
1834 open_view(view, request, OPEN_DEFAULT);
1835 break;
1837 case REQ_NEXT:
1838 case REQ_PREVIOUS:
1839 request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
1841 if (view == VIEW(REQ_VIEW_DIFF) &&
1842 view->parent == VIEW(REQ_VIEW_MAIN)) {
1843 bool redraw = display[1] == view;
1845 view = view->parent;
1846 move_view(view, request, redraw);
1847 if (redraw)
1848 update_view_title(view);
1849 } else {
1850 move_view(view, request, TRUE);
1851 break;
1852 }
1853 /* Fall-through */
1855 case REQ_ENTER:
1856 if (!view->lines) {
1857 report("Nothing to enter");
1858 break;
1859 }
1860 return view->ops->enter(view, &view->line[view->lineno]);
1862 case REQ_VIEW_NEXT:
1863 {
1864 int nviews = displayed_views();
1865 int next_view = (current_view + 1) % nviews;
1867 if (next_view == current_view) {
1868 report("Only one view is displayed");
1869 break;
1870 }
1872 current_view = next_view;
1873 /* Blur out the title of the previous view. */
1874 update_view_title(view);
1875 report("");
1876 break;
1877 }
1878 case REQ_TOGGLE_LINENO:
1879 opt_line_number = !opt_line_number;
1880 redraw_display();
1881 break;
1883 case REQ_TOGGLE_REV_GRAPH:
1884 opt_rev_graph = !opt_rev_graph;
1885 redraw_display();
1886 break;
1888 case REQ_PROMPT:
1889 /* Always reload^Wrerun commands from the prompt. */
1890 open_view(view, opt_request, OPEN_RELOAD);
1891 break;
1893 case REQ_STOP_LOADING:
1894 for (i = 0; i < ARRAY_SIZE(views); i++) {
1895 view = &views[i];
1896 if (view->pipe)
1897 report("Stopped loading the %s view", view->name),
1898 end_update(view);
1899 }
1900 break;
1902 case REQ_SHOW_VERSION:
1903 report("%s (built %s)", VERSION, __DATE__);
1904 return TRUE;
1906 case REQ_SCREEN_RESIZE:
1907 resize_display();
1908 /* Fall-through */
1909 case REQ_SCREEN_REDRAW:
1910 redraw_display();
1911 break;
1913 case REQ_SCREEN_UPDATE:
1914 doupdate();
1915 return TRUE;
1917 case REQ_VIEW_CLOSE:
1918 /* XXX: Mark closed views by letting view->parent point to the
1919 * view itself. Parents to closed view should never be
1920 * followed. */
1921 if (view->parent &&
1922 view->parent->parent != view->parent) {
1923 memset(display, 0, sizeof(display));
1924 current_view = 0;
1925 display[current_view] = view->parent;
1926 view->parent = view;
1927 resize_display();
1928 redraw_display();
1929 break;
1930 }
1931 /* Fall-through */
1932 case REQ_QUIT:
1933 return FALSE;
1935 default:
1936 /* An unknown key will show most commonly used commands. */
1937 report("Unknown key, press 'h' for help");
1938 return TRUE;
1939 }
1941 return TRUE;
1942 }
1945 /*
1946 * Pager backend
1947 */
1949 static bool
1950 pager_draw(struct view *view, struct line *line, unsigned int lineno)
1951 {
1952 char *text = line->data;
1953 enum line_type type = line->type;
1954 int textlen = strlen(text);
1955 int attr;
1957 wmove(view->win, lineno, 0);
1959 if (view->offset + lineno == view->lineno) {
1960 if (type == LINE_COMMIT) {
1961 string_copy(view->ref, text + 7);
1962 string_copy(ref_commit, view->ref);
1963 }
1965 type = LINE_CURSOR;
1966 wchgat(view->win, -1, 0, type, NULL);
1967 }
1969 attr = get_line_attr(type);
1970 wattrset(view->win, attr);
1972 if (opt_line_number || opt_tab_size < TABSIZE) {
1973 static char spaces[] = " ";
1974 int col_offset = 0, col = 0;
1976 if (opt_line_number) {
1977 unsigned long real_lineno = view->offset + lineno + 1;
1979 if (real_lineno == 1 ||
1980 (real_lineno % opt_num_interval) == 0) {
1981 wprintw(view->win, "%.*d", view->digits, real_lineno);
1983 } else {
1984 waddnstr(view->win, spaces,
1985 MIN(view->digits, STRING_SIZE(spaces)));
1986 }
1987 waddstr(view->win, ": ");
1988 col_offset = view->digits + 2;
1989 }
1991 while (text && col_offset + col < view->width) {
1992 int cols_max = view->width - col_offset - col;
1993 char *pos = text;
1994 int cols;
1996 if (*text == '\t') {
1997 text++;
1998 assert(sizeof(spaces) > TABSIZE);
1999 pos = spaces;
2000 cols = opt_tab_size - (col % opt_tab_size);
2002 } else {
2003 text = strchr(text, '\t');
2004 cols = line ? text - pos : strlen(pos);
2005 }
2007 waddnstr(view->win, pos, MIN(cols, cols_max));
2008 col += cols;
2009 }
2011 } else {
2012 int col = 0, pos = 0;
2014 for (; pos < textlen && col < view->width; pos++, col++)
2015 if (text[pos] == '\t')
2016 col += TABSIZE - (col % TABSIZE) - 1;
2018 waddnstr(view->win, text, pos);
2019 }
2021 return TRUE;
2022 }
2024 static void
2025 add_pager_refs(struct view *view, struct line *line)
2026 {
2027 char buf[1024];
2028 char *data = line->data;
2029 struct ref **refs;
2030 int bufpos = 0, refpos = 0;
2031 const char *sep = "Refs: ";
2033 assert(line->type == LINE_COMMIT);
2035 refs = get_refs(data + STRING_SIZE("commit "));
2036 if (!refs)
2037 return;
2039 do {
2040 struct ref *ref = refs[refpos];
2041 char *fmt = ref->tag ? "%s[%s]" : "%s%s";
2043 if (!string_format_from(buf, &bufpos, fmt, sep, ref->name))
2044 return;
2045 sep = ", ";
2046 } while (refs[refpos++]->next);
2048 if (!realloc_lines(view, view->line_size + 1))
2049 return;
2051 line = &view->line[view->lines];
2052 line->data = strdup(buf);
2053 if (!line->data)
2054 return;
2056 line->type = LINE_PP_REFS;
2057 view->lines++;
2058 }
2060 static bool
2061 pager_read(struct view *view, char *data)
2062 {
2063 struct line *line = &view->line[view->lines];
2065 line->data = strdup(data);
2066 if (!line->data)
2067 return FALSE;
2069 line->type = get_line_type(line->data);
2070 view->lines++;
2072 if (line->type == LINE_COMMIT &&
2073 (view == VIEW(REQ_VIEW_DIFF) ||
2074 view == VIEW(REQ_VIEW_LOG)))
2075 add_pager_refs(view, line);
2077 return TRUE;
2078 }
2080 static bool
2081 pager_enter(struct view *view, struct line *line)
2082 {
2083 int split = 0;
2085 if (line->type == LINE_COMMIT &&
2086 (view == VIEW(REQ_VIEW_LOG) ||
2087 view == VIEW(REQ_VIEW_PAGER))) {
2088 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
2089 split = 1;
2090 }
2092 /* Always scroll the view even if it was split. That way
2093 * you can use Enter to scroll through the log view and
2094 * split open each commit diff. */
2095 scroll_view(view, REQ_SCROLL_LINE_DOWN);
2097 /* FIXME: A minor workaround. Scrolling the view will call report("")
2098 * but if we are scrolling a non-current view this won't properly
2099 * update the view title. */
2100 if (split)
2101 update_view_title(view);
2103 return TRUE;
2104 }
2106 static struct view_ops pager_ops = {
2107 "line",
2108 pager_draw,
2109 pager_read,
2110 pager_enter,
2111 };
2114 /*
2115 * Main view backend
2116 */
2118 struct commit {
2119 char id[41]; /* SHA1 ID. */
2120 char title[75]; /* First line of the commit message. */
2121 char author[75]; /* Author of the commit. */
2122 struct tm time; /* Date from the author ident. */
2123 struct ref **refs; /* Repository references. */
2124 chtype graph[SIZEOF_REVGRAPH]; /* Ancestry chain graphics. */
2125 size_t graph_size; /* The width of the graph array. */
2126 };
2128 static bool
2129 main_draw(struct view *view, struct line *line, unsigned int lineno)
2130 {
2131 char buf[DATE_COLS + 1];
2132 struct commit *commit = line->data;
2133 enum line_type type;
2134 int col = 0;
2135 size_t timelen;
2136 size_t authorlen;
2137 int trimmed = 1;
2139 if (!*commit->author)
2140 return FALSE;
2142 wmove(view->win, lineno, col);
2144 if (view->offset + lineno == view->lineno) {
2145 string_copy(view->ref, commit->id);
2146 string_copy(ref_commit, view->ref);
2147 type = LINE_CURSOR;
2148 wattrset(view->win, get_line_attr(type));
2149 wchgat(view->win, -1, 0, type, NULL);
2151 } else {
2152 type = LINE_MAIN_COMMIT;
2153 wattrset(view->win, get_line_attr(LINE_MAIN_DATE));
2154 }
2156 timelen = strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time);
2157 waddnstr(view->win, buf, timelen);
2158 waddstr(view->win, " ");
2160 col += DATE_COLS;
2161 wmove(view->win, lineno, col);
2162 if (type != LINE_CURSOR)
2163 wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
2165 if (opt_utf8) {
2166 authorlen = utf8_length(commit->author, AUTHOR_COLS - 2, &col, &trimmed);
2167 } else {
2168 authorlen = strlen(commit->author);
2169 if (authorlen > AUTHOR_COLS - 2) {
2170 authorlen = AUTHOR_COLS - 2;
2171 trimmed = 1;
2172 }
2173 }
2175 if (trimmed) {
2176 waddnstr(view->win, commit->author, authorlen);
2177 if (type != LINE_CURSOR)
2178 wattrset(view->win, get_line_attr(LINE_MAIN_DELIM));
2179 waddch(view->win, '~');
2180 } else {
2181 waddstr(view->win, commit->author);
2182 }
2184 col += AUTHOR_COLS;
2185 if (type != LINE_CURSOR)
2186 wattrset(view->win, A_NORMAL);
2188 if (opt_rev_graph && commit->graph_size) {
2189 size_t i;
2191 wmove(view->win, lineno, col);
2192 /* Using waddch() instead of waddnstr() ensures that
2193 * they'll be rendered correctly for the cursor line. */
2194 for (i = 0; i < commit->graph_size; i++)
2195 waddch(view->win, commit->graph[i]);
2197 col += commit->graph_size + 1;
2198 }
2200 wmove(view->win, lineno, col);
2202 if (commit->refs) {
2203 size_t i = 0;
2205 do {
2206 if (type == LINE_CURSOR)
2207 ;
2208 else if (commit->refs[i]->tag)
2209 wattrset(view->win, get_line_attr(LINE_MAIN_TAG));
2210 else
2211 wattrset(view->win, get_line_attr(LINE_MAIN_REF));
2212 waddstr(view->win, "[");
2213 waddstr(view->win, commit->refs[i]->name);
2214 waddstr(view->win, "]");
2215 if (type != LINE_CURSOR)
2216 wattrset(view->win, A_NORMAL);
2217 waddstr(view->win, " ");
2218 col += strlen(commit->refs[i]->name) + STRING_SIZE("[] ");
2219 } while (commit->refs[i++]->next);
2220 }
2222 if (type != LINE_CURSOR)
2223 wattrset(view->win, get_line_attr(type));
2225 {
2226 int titlelen = strlen(commit->title);
2228 if (col + titlelen > view->width)
2229 titlelen = view->width - col;
2231 waddnstr(view->win, commit->title, titlelen);
2232 }
2234 return TRUE;
2235 }
2237 /* Reads git log --pretty=raw output and parses it into the commit struct. */
2238 static bool
2239 main_read(struct view *view, char *line)
2240 {
2241 enum line_type type = get_line_type(line);
2242 struct commit *commit = view->lines
2243 ? view->line[view->lines - 1].data : NULL;
2245 switch (type) {
2246 case LINE_COMMIT:
2247 commit = calloc(1, sizeof(struct commit));
2248 if (!commit)
2249 return FALSE;
2251 line += STRING_SIZE("commit ");
2253 view->line[view->lines++].data = commit;
2254 string_copy(commit->id, line);
2255 commit->refs = get_refs(commit->id);
2256 commit->graph[commit->graph_size++] = ACS_LTEE;
2257 break;
2259 case LINE_AUTHOR:
2260 {
2261 char *ident = line + STRING_SIZE("author ");
2262 char *end = strchr(ident, '<');
2264 if (!commit)
2265 break;
2267 if (end) {
2268 for (; end > ident && isspace(end[-1]); end--) ;
2269 *end = 0;
2270 }
2272 string_copy(commit->author, ident);
2274 /* Parse epoch and timezone */
2275 if (end) {
2276 char *secs = strchr(end + 1, '>');
2277 char *zone;
2278 time_t time;
2280 if (!secs || secs[1] != ' ')
2281 break;
2283 secs += 2;
2284 time = (time_t) atol(secs);
2285 zone = strchr(secs, ' ');
2286 if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
2287 long tz;
2289 zone++;
2290 tz = ('0' - zone[1]) * 60 * 60 * 10;
2291 tz += ('0' - zone[2]) * 60 * 60;
2292 tz += ('0' - zone[3]) * 60;
2293 tz += ('0' - zone[4]) * 60;
2295 if (zone[0] == '-')
2296 tz = -tz;
2298 time -= tz;
2299 }
2300 gmtime_r(&time, &commit->time);
2301 }
2302 break;
2303 }
2304 default:
2305 if (!commit)
2306 break;
2308 /* Fill in the commit title if it has not already been set. */
2309 if (commit->title[0])
2310 break;
2312 /* Require titles to start with a non-space character at the
2313 * offset used by git log. */
2314 /* FIXME: More gracefull handling of titles; append "..." to
2315 * shortened titles, etc. */
2316 if (strncmp(line, " ", 4) ||
2317 isspace(line[4]))
2318 break;
2320 string_copy(commit->title, line + 4);
2321 }
2323 return TRUE;
2324 }
2326 static bool
2327 main_enter(struct view *view, struct line *line)
2328 {
2329 enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
2331 open_view(view, REQ_VIEW_DIFF, flags);
2332 return TRUE;
2333 }
2335 static struct view_ops main_ops = {
2336 "commit",
2337 main_draw,
2338 main_read,
2339 main_enter,
2340 };
2343 /*
2344 * Unicode / UTF-8 handling
2345 *
2346 * NOTE: Much of the following code for dealing with unicode is derived from
2347 * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
2348 * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
2349 */
2351 /* I've (over)annotated a lot of code snippets because I am not entirely
2352 * confident that the approach taken by this small UTF-8 interface is correct.
2353 * --jonas */
2355 static inline int
2356 unicode_width(unsigned long c)
2357 {
2358 if (c >= 0x1100 &&
2359 (c <= 0x115f /* Hangul Jamo */
2360 || c == 0x2329
2361 || c == 0x232a
2362 || (c >= 0x2e80 && c <= 0xa4cf && c != 0x303f)
2363 /* CJK ... Yi */
2364 || (c >= 0xac00 && c <= 0xd7a3) /* Hangul Syllables */
2365 || (c >= 0xf900 && c <= 0xfaff) /* CJK Compatibility Ideographs */
2366 || (c >= 0xfe30 && c <= 0xfe6f) /* CJK Compatibility Forms */
2367 || (c >= 0xff00 && c <= 0xff60) /* Fullwidth Forms */
2368 || (c >= 0xffe0 && c <= 0xffe6)
2369 || (c >= 0x20000 && c <= 0x2fffd)
2370 || (c >= 0x30000 && c <= 0x3fffd)))
2371 return 2;
2373 return 1;
2374 }
2376 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
2377 * Illegal bytes are set one. */
2378 static const unsigned char utf8_bytes[256] = {
2379 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,
2380 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,
2381 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,
2382 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,
2383 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,
2384 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,
2385 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,
2386 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,
2387 };
2389 /* Decode UTF-8 multi-byte representation into a unicode character. */
2390 static inline unsigned long
2391 utf8_to_unicode(const char *string, size_t length)
2392 {
2393 unsigned long unicode;
2395 switch (length) {
2396 case 1:
2397 unicode = string[0];
2398 break;
2399 case 2:
2400 unicode = (string[0] & 0x1f) << 6;
2401 unicode += (string[1] & 0x3f);
2402 break;
2403 case 3:
2404 unicode = (string[0] & 0x0f) << 12;
2405 unicode += ((string[1] & 0x3f) << 6);
2406 unicode += (string[2] & 0x3f);
2407 break;
2408 case 4:
2409 unicode = (string[0] & 0x0f) << 18;
2410 unicode += ((string[1] & 0x3f) << 12);
2411 unicode += ((string[2] & 0x3f) << 6);
2412 unicode += (string[3] & 0x3f);
2413 break;
2414 case 5:
2415 unicode = (string[0] & 0x0f) << 24;
2416 unicode += ((string[1] & 0x3f) << 18);
2417 unicode += ((string[2] & 0x3f) << 12);
2418 unicode += ((string[3] & 0x3f) << 6);
2419 unicode += (string[4] & 0x3f);
2420 break;
2421 case 6:
2422 unicode = (string[0] & 0x01) << 30;
2423 unicode += ((string[1] & 0x3f) << 24);
2424 unicode += ((string[2] & 0x3f) << 18);
2425 unicode += ((string[3] & 0x3f) << 12);
2426 unicode += ((string[4] & 0x3f) << 6);
2427 unicode += (string[5] & 0x3f);
2428 break;
2429 default:
2430 die("Invalid unicode length");
2431 }
2433 /* Invalid characters could return the special 0xfffd value but NUL
2434 * should be just as good. */
2435 return unicode > 0xffff ? 0 : unicode;
2436 }
2438 /* Calculates how much of string can be shown within the given maximum width
2439 * and sets trimmed parameter to non-zero value if all of string could not be
2440 * shown.
2441 *
2442 * Additionally, adds to coloffset how many many columns to move to align with
2443 * the expected position. Takes into account how multi-byte and double-width
2444 * characters will effect the cursor position.
2445 *
2446 * Returns the number of bytes to output from string to satisfy max_width. */
2447 static size_t
2448 utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed)
2449 {
2450 const char *start = string;
2451 const char *end = strchr(string, '\0');
2452 size_t mbwidth = 0;
2453 size_t width = 0;
2455 *trimmed = 0;
2457 while (string < end) {
2458 int c = *(unsigned char *) string;
2459 unsigned char bytes = utf8_bytes[c];
2460 size_t ucwidth;
2461 unsigned long unicode;
2463 if (string + bytes > end)
2464 break;
2466 /* Change representation to figure out whether
2467 * it is a single- or double-width character. */
2469 unicode = utf8_to_unicode(string, bytes);
2470 /* FIXME: Graceful handling of invalid unicode character. */
2471 if (!unicode)
2472 break;
2474 ucwidth = unicode_width(unicode);
2475 width += ucwidth;
2476 if (width > max_width) {
2477 *trimmed = 1;
2478 break;
2479 }
2481 /* The column offset collects the differences between the
2482 * number of bytes encoding a character and the number of
2483 * columns will be used for rendering said character.
2484 *
2485 * So if some character A is encoded in 2 bytes, but will be
2486 * represented on the screen using only 1 byte this will and up
2487 * adding 1 to the multi-byte column offset.
2488 *
2489 * Assumes that no double-width character can be encoding in
2490 * less than two bytes. */
2491 if (bytes > ucwidth)
2492 mbwidth += bytes - ucwidth;
2494 string += bytes;
2495 }
2497 *coloffset += mbwidth;
2499 return string - start;
2500 }
2503 /*
2504 * Status management
2505 */
2507 /* Whether or not the curses interface has been initialized. */
2508 static bool cursed = FALSE;
2510 /* The status window is used for polling keystrokes. */
2511 static WINDOW *status_win;
2513 /* Update status and title window. */
2514 static void
2515 report(const char *msg, ...)
2516 {
2517 static bool empty = TRUE;
2518 struct view *view = display[current_view];
2520 if (!empty || *msg) {
2521 va_list args;
2523 va_start(args, msg);
2525 werase(status_win);
2526 wmove(status_win, 0, 0);
2527 if (*msg) {
2528 vwprintw(status_win, msg, args);
2529 empty = FALSE;
2530 } else {
2531 empty = TRUE;
2532 }
2533 wrefresh(status_win);
2535 va_end(args);
2536 }
2538 update_view_title(view);
2539 update_display_cursor();
2540 }
2542 /* Controls when nodelay should be in effect when polling user input. */
2543 static void
2544 set_nonblocking_input(bool loading)
2545 {
2546 static unsigned int loading_views;
2548 if ((loading == FALSE && loading_views-- == 1) ||
2549 (loading == TRUE && loading_views++ == 0))
2550 nodelay(status_win, loading);
2551 }
2553 static void
2554 init_display(void)
2555 {
2556 int x, y;
2558 /* Initialize the curses library */
2559 if (isatty(STDIN_FILENO)) {
2560 cursed = !!initscr();
2561 } else {
2562 /* Leave stdin and stdout alone when acting as a pager. */
2563 FILE *io = fopen("/dev/tty", "r+");
2565 cursed = !!newterm(NULL, io, io);
2566 }
2568 if (!cursed)
2569 die("Failed to initialize curses");
2571 nonl(); /* Tell curses not to do NL->CR/NL on output */
2572 cbreak(); /* Take input chars one at a time, no wait for \n */
2573 noecho(); /* Don't echo input */
2574 leaveok(stdscr, TRUE);
2576 if (has_colors())
2577 init_colors();
2579 getmaxyx(stdscr, y, x);
2580 status_win = newwin(1, 0, y - 1, 0);
2581 if (!status_win)
2582 die("Failed to create status window");
2584 /* Enable keyboard mapping */
2585 keypad(status_win, TRUE);
2586 wbkgdset(status_win, get_line_attr(LINE_STATUS));
2587 }
2590 /*
2591 * Repository references
2592 */
2594 static struct ref *refs;
2595 static size_t refs_size;
2597 /* Id <-> ref store */
2598 static struct ref ***id_refs;
2599 static size_t id_refs_size;
2601 static struct ref **
2602 get_refs(char *id)
2603 {
2604 struct ref ***tmp_id_refs;
2605 struct ref **ref_list = NULL;
2606 size_t ref_list_size = 0;
2607 size_t i;
2609 for (i = 0; i < id_refs_size; i++)
2610 if (!strcmp(id, id_refs[i][0]->id))
2611 return id_refs[i];
2613 tmp_id_refs = realloc(id_refs, (id_refs_size + 1) * sizeof(*id_refs));
2614 if (!tmp_id_refs)
2615 return NULL;
2617 id_refs = tmp_id_refs;
2619 for (i = 0; i < refs_size; i++) {
2620 struct ref **tmp;
2622 if (strcmp(id, refs[i].id))
2623 continue;
2625 tmp = realloc(ref_list, (ref_list_size + 1) * sizeof(*ref_list));
2626 if (!tmp) {
2627 if (ref_list)
2628 free(ref_list);
2629 return NULL;
2630 }
2632 ref_list = tmp;
2633 if (ref_list_size > 0)
2634 ref_list[ref_list_size - 1]->next = 1;
2635 ref_list[ref_list_size] = &refs[i];
2637 /* XXX: The properties of the commit chains ensures that we can
2638 * safely modify the shared ref. The repo references will
2639 * always be similar for the same id. */
2640 ref_list[ref_list_size]->next = 0;
2641 ref_list_size++;
2642 }
2644 if (ref_list)
2645 id_refs[id_refs_size++] = ref_list;
2647 return ref_list;
2648 }
2650 static int
2651 read_ref(char *id, int idlen, char *name, int namelen)
2652 {
2653 struct ref *ref;
2654 bool tag = FALSE;
2656 if (!strncmp(name, "refs/tags/", STRING_SIZE("refs/tags/"))) {
2657 /* Commits referenced by tags has "^{}" appended. */
2658 if (name[namelen - 1] != '}')
2659 return OK;
2661 while (namelen > 0 && name[namelen] != '^')
2662 namelen--;
2664 tag = TRUE;
2665 namelen -= STRING_SIZE("refs/tags/");
2666 name += STRING_SIZE("refs/tags/");
2668 } else if (!strncmp(name, "refs/heads/", STRING_SIZE("refs/heads/"))) {
2669 namelen -= STRING_SIZE("refs/heads/");
2670 name += STRING_SIZE("refs/heads/");
2672 } else if (!strcmp(name, "HEAD")) {
2673 return OK;
2674 }
2676 refs = realloc(refs, sizeof(*refs) * (refs_size + 1));
2677 if (!refs)
2678 return ERR;
2680 ref = &refs[refs_size++];
2681 ref->name = malloc(namelen + 1);
2682 if (!ref->name)
2683 return ERR;
2685 strncpy(ref->name, name, namelen);
2686 ref->name[namelen] = 0;
2687 ref->tag = tag;
2688 string_copy(ref->id, id);
2690 return OK;
2691 }
2693 static int
2694 load_refs(void)
2695 {
2696 const char *cmd_env = getenv("TIG_LS_REMOTE");
2697 const char *cmd = cmd_env && *cmd_env ? cmd_env : TIG_LS_REMOTE;
2699 return read_properties(popen(cmd, "r"), "\t", read_ref);
2700 }
2702 static int
2703 read_repo_config_option(char *name, int namelen, char *value, int valuelen)
2704 {
2705 if (!strcmp(name, "i18n.commitencoding"))
2706 string_copy(opt_encoding, value);
2708 return OK;
2709 }
2711 static int
2712 load_repo_config(void)
2713 {
2714 return read_properties(popen("git repo-config --list", "r"),
2715 "=", read_repo_config_option);
2716 }
2718 static int
2719 read_properties(FILE *pipe, const char *separators,
2720 int (*read_property)(char *, int, char *, int))
2721 {
2722 char buffer[BUFSIZ];
2723 char *name;
2724 int state = OK;
2726 if (!pipe)
2727 return ERR;
2729 while (state == OK && (name = fgets(buffer, sizeof(buffer), pipe))) {
2730 char *value;
2731 size_t namelen;
2732 size_t valuelen;
2734 name = chomp_string(name);
2735 namelen = strcspn(name, separators);
2737 if (name[namelen]) {
2738 name[namelen] = 0;
2739 value = chomp_string(name + namelen + 1);
2740 valuelen = strlen(value);
2742 } else {
2743 value = "";
2744 valuelen = 0;
2745 }
2747 state = read_property(name, namelen, value, valuelen);
2748 }
2750 if (state != ERR && ferror(pipe))
2751 state = ERR;
2753 pclose(pipe);
2755 return state;
2756 }
2759 /*
2760 * Main
2761 */
2763 static void __NORETURN
2764 quit(int sig)
2765 {
2766 /* XXX: Restore tty modes and let the OS cleanup the rest! */
2767 if (cursed)
2768 endwin();
2769 exit(0);
2770 }
2772 static void __NORETURN
2773 die(const char *err, ...)
2774 {
2775 va_list args;
2777 endwin();
2779 va_start(args, err);
2780 fputs("tig: ", stderr);
2781 vfprintf(stderr, err, args);
2782 fputs("\n", stderr);
2783 va_end(args);
2785 exit(1);
2786 }
2788 int
2789 main(int argc, char *argv[])
2790 {
2791 struct view *view;
2792 enum request request;
2793 size_t i;
2795 signal(SIGINT, quit);
2797 if (load_options() == ERR)
2798 die("Failed to load user config.");
2800 /* Load the repo config file so options can be overwritten from
2801 * the command line. */
2802 if (load_repo_config() == ERR)
2803 die("Failed to load repo config.");
2805 if (!parse_options(argc, argv))
2806 return 0;
2808 if (load_refs() == ERR)
2809 die("Failed to load refs.");
2811 /* Require a git repository unless when running in pager mode. */
2812 if (refs_size == 0 && opt_request != REQ_VIEW_PAGER)
2813 die("Not a git repository");
2815 for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
2816 view->cmd_env = getenv(view->cmd_env);
2818 request = opt_request;
2820 init_display();
2822 while (view_driver(display[current_view], request)) {
2823 int key;
2824 int i;
2826 foreach_view (view, i)
2827 update_view(view);
2829 /* Refresh, accept single keystroke of input */
2830 key = wgetch(status_win);
2832 request = get_keybinding(display[current_view]->keymap, key);
2834 /* Some low-level request handling. This keeps access to
2835 * status_win restricted. */
2836 switch (request) {
2837 case REQ_PROMPT:
2838 report(":");
2839 /* Temporarily switch to line-oriented and echoed
2840 * input. */
2841 nocbreak();
2842 echo();
2844 if (wgetnstr(status_win, opt_cmd + 4, sizeof(opt_cmd) - 4) == OK) {
2845 memcpy(opt_cmd, "git ", 4);
2846 opt_request = REQ_VIEW_PAGER;
2847 } else {
2848 report("Prompt interrupted by loading view, "
2849 "press 'z' to stop loading views");
2850 request = REQ_SCREEN_UPDATE;
2851 }
2853 noecho();
2854 cbreak();
2855 break;
2857 case REQ_SCREEN_RESIZE:
2858 {
2859 int height, width;
2861 getmaxyx(stdscr, height, width);
2863 /* Resize the status view and let the view driver take
2864 * care of resizing the displayed views. */
2865 wresize(status_win, 1, width);
2866 mvwin(status_win, height - 1, 0);
2867 wrefresh(status_win);
2868 break;
2869 }
2870 default:
2871 break;
2872 }
2873 }
2875 quit(0);
2877 return 0;
2878 }