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