~mdw / tig / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Support set command in ~/.tigrc; allows a few options to be configured
[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 * User config file handling.
605 */
606
607 static struct int_map color_map[] = {
608 #define COLOR_MAP(name) { #name, STRING_SIZE(#name), COLOR_##name }
609 COLOR_MAP(DEFAULT),
610 COLOR_MAP(BLACK),
611 COLOR_MAP(BLUE),
612 COLOR_MAP(CYAN),
613 COLOR_MAP(GREEN),
614 COLOR_MAP(MAGENTA),
615 COLOR_MAP(RED),
616 COLOR_MAP(WHITE),
617 COLOR_MAP(YELLOW),
618 };
619
620 #define set_color(color, name) \
621 set_from_int_map(color_map, ARRAY_SIZE(color_map), color, name, strlen(name))
622
623 static struct int_map attr_map[] = {
624 #define ATTR_MAP(name) { #name, STRING_SIZE(#name), A_##name }
625 ATTR_MAP(NORMAL),
626 ATTR_MAP(BLINK),
627 ATTR_MAP(BOLD),
628 ATTR_MAP(DIM),
629 ATTR_MAP(REVERSE),
630 ATTR_MAP(STANDOUT),
631 ATTR_MAP(UNDERLINE),
632 };
633
634 #define set_attribute(attr, name) \
635 set_from_int_map(attr_map, ARRAY_SIZE(attr_map), attr, name, strlen(name))
636
637 static int config_lineno;
638 static bool config_errors;
639 static char *config_msg;
640
641 /* Wants: object fgcolor bgcolor [attr] */
642 static int
643 option_color_command(int argc, char *argv[])
644 {
645 struct line_info *info;
646
647 if (argc != 3 && argc != 4) {
648 config_msg = "Wrong number of arguments given to color command";
649 return ERR;
650 }
651
652 info = get_line_info(argv[0], strlen(argv[0]));
653 if (!info) {
654 config_msg = "Unknown color name";
655 return ERR;
656 }
657
658 if (set_color(&info->fg, argv[1]) == ERR) {
659 config_msg = "Unknown color";
660 return ERR;
661 }
662
663 if (set_color(&info->bg, argv[2]) == ERR) {
664 config_msg = "Unknown color";
665 return ERR;
666 }
667
668 if (argc == 4 && set_attribute(&info->attr, argv[3]) == ERR) {
669 config_msg = "Unknown attribute";
670 return ERR;
671 }
672
673 return OK;
674 }
675
676 /* Wants: name = value */
677 static int
678 option_set_command(int argc, char *argv[])
679 {
680 if (argc != 3) {
681 config_msg = "Wrong number of arguments given to set command";
682 return ERR;
683 }
684
685 if (strcmp(argv[1], "=")) {
686 config_msg = "No value assigned";
687 return ERR;
688 }
689
690 if (!strcmp(argv[0], "show-rev-graph")) {
691 opt_rev_graph = (!strcmp(argv[2], "1") ||
692 !strcmp(argv[2], "true") ||
693 !strcmp(argv[2], "yes"));
694 return OK;
695 }
696
697 if (!strcmp(argv[0], "line-number-interval")) {
698 opt_num_interval = atoi(argv[2]);
699 return OK;
700 }
701
702 if (!strcmp(argv[0], "tab-size")) {
703 opt_tab_size = atoi(argv[2]);
704 return OK;
705 }
706
707 if (!strcmp(argv[0], "encoding")) {
708 string_copy(opt_encoding, argv[2]);
709 return OK;
710 }
711
712 return ERR;
713 }
714
715 static int
716 set_option(char *opt, char *value)
717 {
718 char *argv[16];
719 int valuelen;
720 int argc = 0;
721
722 /* Tokenize */
723 while (argc < ARRAY_SIZE(argv) && (valuelen = strcspn(value, " \t"))) {
724 argv[argc++] = value;
725
726 value += valuelen;
727 if (!*value)
728 break;
729
730 *value++ = 0;
731 while (isspace(*value))
732 value++;
733 }
734
735 if (!strcmp(opt, "color"))
736 return option_color_command(argc, argv);
737
738 if (!strcmp(opt, "set"))
739 return option_set_command(argc, argv);
740
741 return ERR;
742 }
743
744 static int
745 read_option(char *opt, int optlen, char *value, int valuelen)
746 {
747 config_lineno++;
748 config_msg = "Internal error";
749
750 optlen = strcspn(opt, "#;");
751 if (optlen == 0) {
752 /* The whole line is a commend or empty. */
753 return OK;
754
755 } else if (opt[optlen] != 0) {
756 /* Part of the option name is a comment, so the value part
757 * should be ignored. */
758 valuelen = 0;
759 opt[optlen] = value[valuelen] = 0;
760 } else {
761 /* Else look for comment endings in the value. */
762 valuelen = strcspn(value, "#;");
763 value[valuelen] = 0;
764 }
765
766 if (set_option(opt, value) == ERR) {
767 fprintf(stderr, "Error on line %d, near '%.*s' option: %s\n",
768 config_lineno, optlen, opt, config_msg);
769 config_errors = TRUE;
770 }
771
772 /* Always keep going if errors are encountered. */
773 return OK;
774 }
775
776 static int
777 load_options(void)
778 {
779 char *home = getenv("HOME");
780 char buf[1024];
781 FILE *file;
782
783 config_lineno = 0;
784 config_errors = FALSE;
785
786 if (!home || !string_format(buf, "%s/.tigrc", home))
787 return ERR;
788
789 /* It's ok that the file doesn't exist. */
790 file = fopen(buf, "r");
791 if (!file)
792 return OK;
793
794 if (read_properties(file, " \t", read_option) == ERR ||
795 config_errors == TRUE)
796 fprintf(stderr, "Errors while loading %s.\n", buf);
797
798 return OK;
799 }
800
801
802 /*
803 * The viewer
804 */
805
806 struct view;
807 struct view_ops;
808
809 /* The display array of active views and the index of the current view. */
810 static struct view *display[2];
811 static unsigned int current_view;
812
813 #define foreach_view(view, i) \
814 for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
815
816 #define displayed_views() (display[1] != NULL ? 2 : 1)
817
818 /* Current head and commit ID */
819 static char ref_commit[SIZEOF_REF] = "HEAD";
820 static char ref_head[SIZEOF_REF] = "HEAD";
821
822 struct view {
823 const char *name; /* View name */
824 const char *cmd_fmt; /* Default command line format */
825 const char *cmd_env; /* Command line set via environment */
826 const char *id; /* Points to either of ref_{head,commit} */
827
828 struct view_ops *ops; /* View operations */
829
830 char cmd[SIZEOF_CMD]; /* Command buffer */
831 char ref[SIZEOF_REF]; /* Hovered commit reference */
832 char vid[SIZEOF_REF]; /* View ID. Set to id member when updating. */
833
834 int height, width; /* The width and height of the main window */
835 WINDOW *win; /* The main window */
836 WINDOW *title; /* The title window living below the main window */
837
838 /* Navigation */
839 unsigned long offset; /* Offset of the window top */
840 unsigned long lineno; /* Current line number */
841
842 /* If non-NULL, points to the view that opened this view. If this view
843 * is closed tig will switch back to the parent view. */
844 struct view *parent;
845
846 /* Buffering */
847 unsigned long lines; /* Total number of lines */
848 struct line *line; /* Line index */
849 unsigned long line_size;/* Total number of allocated lines */
850 unsigned int digits; /* Number of digits in the lines member. */
851
852 /* Loading */
853 FILE *pipe;
854 time_t start_time;
855 };
856
857 struct view_ops {
858 /* What type of content being displayed. Used in the title bar. */
859 const char *type;
860 /* Draw one line; @lineno must be < view->height. */
861 bool (*draw)(struct view *view, struct line *line, unsigned int lineno);
862 /* Read one line; updates view->line. */
863 bool (*read)(struct view *view, char *data);
864 /* Depending on view, change display based on current line. */
865 bool (*enter)(struct view *view, struct line *line);
866 };
867
868 static struct view_ops pager_ops;
869 static struct view_ops main_ops;
870
871 #define VIEW_STR(name, cmd, env, ref, ops) \
872 { name, cmd, #env, ref, ops }
873
874 #define VIEW_(id, name, ops, ref) \
875 VIEW_STR(name, TIG_##id##_CMD, TIG_##id##_CMD, ref, ops)
876
877
878 static struct view views[] = {
879 VIEW_(MAIN, "main", &main_ops, ref_head),
880 VIEW_(DIFF, "diff", &pager_ops, ref_commit),
881 VIEW_(LOG, "log", &pager_ops, ref_head),
882 VIEW_(HELP, "help", &pager_ops, "static"),
883 VIEW_(PAGER, "pager", &pager_ops, "static"),
884 };
885
886 #define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
887
888
889 static bool
890 draw_view_line(struct view *view, unsigned int lineno)
891 {
892 if (view->offset + lineno >= view->lines)
893 return FALSE;
894
895 return view->ops->draw(view, &view->line[view->offset + lineno], lineno);
896 }
897
898 static void
899 redraw_view_from(struct view *view, int lineno)
900 {
901 assert(0 <= lineno && lineno < view->height);
902
903 for (; lineno < view->height; lineno++) {
904 if (!draw_view_line(view, lineno))
905 break;
906 }
907
908 redrawwin(view->win);
909 wrefresh(view->win);
910 }
911
912 static void
913 redraw_view(struct view *view)
914 {
915 wclear(view->win);
916 redraw_view_from(view, 0);
917 }
918
919
920 static void
921 update_view_title(struct view *view)
922 {
923 if (view == display[current_view])
924 wbkgdset(view->title, get_line_attr(LINE_TITLE_FOCUS));
925 else
926 wbkgdset(view->title, get_line_attr(LINE_TITLE_BLUR));
927
928 werase(view->title);
929 wmove(view->title, 0, 0);
930
931 if (*view->ref)
932 wprintw(view->title, "[%s] %s", view->name, view->ref);
933 else
934 wprintw(view->title, "[%s]", view->name);
935
936 if (view->lines || view->pipe) {
937 unsigned int view_lines = view->offset + view->height;
938 unsigned int lines = view->lines
939 ? MIN(view_lines, view->lines) * 100 / view->lines
940 : 0;
941
942 wprintw(view->title, " - %s %d of %d (%d%%)",
943 view->ops->type,
944 view->lineno + 1,
945 view->lines,
946 lines);
947 }
948
949 if (view->pipe) {
950 time_t secs = time(NULL) - view->start_time;
951
952 /* Three git seconds are a long time ... */
953 if (secs > 2)
954 wprintw(view->title, " %lds", secs);
955 }
956
957 wmove(view->title, 0, view->width - 1);
958 wrefresh(view->title);
959 }
960
961 static void
962 resize_display(void)
963 {
964 int offset, i;
965 struct view *base = display[0];
966 struct view *view = display[1] ? display[1] : display[0];
967
968 /* Setup window dimensions */
969
970 getmaxyx(stdscr, base->height, base->width);
971
972 /* Make room for the status window. */
973 base->height -= 1;
974
975 if (view != base) {
976 /* Horizontal split. */
977 view->width = base->width;
978 view->height = SCALE_SPLIT_VIEW(base->height);
979 base->height -= view->height;
980
981 /* Make room for the title bar. */
982 view->height -= 1;
983 }
984
985 /* Make room for the title bar. */
986 base->height -= 1;
987
988 offset = 0;
989
990 foreach_view (view, i) {
991 if (!view->win) {
992 view->win = newwin(view->height, 0, offset, 0);
993 if (!view->win)
994 die("Failed to create %s view", view->name);
995
996 scrollok(view->win, TRUE);
997
998 view->title = newwin(1, 0, offset + view->height, 0);
999 if (!view->title)
1000 die("Failed to create title window");
1001
1002 } else {
1003 wresize(view->win, view->height, view->width);
1004 mvwin(view->win, offset, 0);
1005 mvwin(view->title, offset + view->height, 0);
1006 }
1007
1008 offset += view->height + 1;
1009 }
1010 }
1011
1012 static void
1013 redraw_display(void)
1014 {
1015 struct view *view;
1016 int i;
1017
1018 foreach_view (view, i) {
1019 redraw_view(view);
1020 update_view_title(view);
1021 }
1022 }
1023
1024 static void
1025 update_display_cursor(void)
1026 {
1027 struct view *view = display[current_view];
1028
1029 /* Move the cursor to the right-most column of the cursor line.
1030 *
1031 * XXX: This could turn out to be a bit expensive, but it ensures that
1032 * the cursor does not jump around. */
1033 if (view->lines) {
1034 wmove(view->win, view->lineno - view->offset, view->width - 1);
1035 wrefresh(view->win);
1036 }
1037 }
1038
1039 /*
1040 * Navigation
1041 */
1042
1043 /* Scrolling backend */
1044 static void
1045 do_scroll_view(struct view *view, int lines, bool redraw)
1046 {
1047 /* The rendering expects the new offset. */
1048 view->offset += lines;
1049
1050 assert(0 <= view->offset && view->offset < view->lines);
1051 assert(lines);
1052
1053 /* Redraw the whole screen if scrolling is pointless. */
1054 if (view->height < ABS(lines)) {
1055 redraw_view(view);
1056
1057 } else {
1058 int line = lines > 0 ? view->height - lines : 0;
1059 int end = line + ABS(lines);
1060
1061 wscrl(view->win, lines);
1062
1063 for (; line < end; line++) {
1064 if (!draw_view_line(view, line))
1065 break;
1066 }
1067 }
1068
1069 /* Move current line into the view. */
1070 if (view->lineno < view->offset) {
1071 view->lineno = view->offset;
1072 draw_view_line(view, 0);
1073
1074 } else if (view->lineno >= view->offset + view->height) {
1075 if (view->lineno == view->offset + view->height) {
1076 /* Clear the hidden line so it doesn't show if the view
1077 * is scrolled up. */
1078 wmove(view->win, view->height, 0);
1079 wclrtoeol(view->win);
1080 }
1081 view->lineno = view->offset + view->height - 1;
1082 draw_view_line(view, view->lineno - view->offset);
1083 }
1084
1085 assert(view->offset <= view->lineno && view->lineno < view->lines);
1086
1087 if (!redraw)
1088 return;
1089
1090 redrawwin(view->win);
1091 wrefresh(view->win);
1092 report("");
1093 }
1094
1095 /* Scroll frontend */
1096 static void
1097 scroll_view(struct view *view, enum request request)
1098 {
1099 int lines = 1;
1100
1101 switch (request) {
1102 case REQ_SCROLL_PAGE_DOWN:
1103 lines = view->height;
1104 case REQ_SCROLL_LINE_DOWN:
1105 if (view->offset + lines > view->lines)
1106 lines = view->lines - view->offset;
1107
1108 if (lines == 0 || view->offset + view->height >= view->lines) {
1109 report("Cannot scroll beyond the last line");
1110 return;
1111 }
1112 break;
1113
1114 case REQ_SCROLL_PAGE_UP:
1115 lines = view->height;
1116 case REQ_SCROLL_LINE_UP:
1117 if (lines > view->offset)
1118 lines = view->offset;
1119
1120 if (lines == 0) {
1121 report("Cannot scroll beyond the first line");
1122 return;
1123 }
1124
1125 lines = -lines;
1126 break;
1127
1128 default:
1129 die("request %d not handled in switch", request);
1130 }
1131
1132 do_scroll_view(view, lines, TRUE);
1133 }
1134
1135 /* Cursor moving */
1136 static void
1137 move_view(struct view *view, enum request request, bool redraw)
1138 {
1139 int steps;
1140
1141 switch (request) {
1142 case REQ_MOVE_FIRST_LINE:
1143 steps = -view->lineno;
1144 break;
1145
1146 case REQ_MOVE_LAST_LINE:
1147 steps = view->lines - view->lineno - 1;
1148 break;
1149
1150 case REQ_MOVE_PAGE_UP:
1151 steps = view->height > view->lineno
1152 ? -view->lineno : -view->height;
1153 break;
1154
1155 case REQ_MOVE_PAGE_DOWN:
1156 steps = view->lineno + view->height >= view->lines
1157 ? view->lines - view->lineno - 1 : view->height;
1158 break;
1159
1160 case REQ_MOVE_UP:
1161 steps = -1;
1162 break;
1163
1164 case REQ_MOVE_DOWN:
1165 steps = 1;
1166 break;
1167
1168 default:
1169 die("request %d not handled in switch", request);
1170 }
1171
1172 if (steps <= 0 && view->lineno == 0) {
1173 report("Cannot move beyond the first line");
1174 return;
1175
1176 } else if (steps >= 0 && view->lineno + 1 >= view->lines) {
1177 report("Cannot move beyond the last line");
1178 return;
1179 }
1180
1181 /* Move the current line */
1182 view->lineno += steps;
1183 assert(0 <= view->lineno && view->lineno < view->lines);
1184
1185 /* Repaint the old "current" line if we be scrolling */
1186 if (ABS(steps) < view->height) {
1187 int prev_lineno = view->lineno - steps - view->offset;
1188
1189 wmove(view->win, prev_lineno, 0);
1190 wclrtoeol(view->win);
1191 draw_view_line(view, prev_lineno);
1192 }
1193
1194 /* Check whether the view needs to be scrolled */
1195 if (view->lineno < view->offset ||
1196 view->lineno >= view->offset + view->height) {
1197 if (steps < 0 && -steps > view->offset) {
1198 steps = -view->offset;
1199
1200 } else if (steps > 0) {
1201 if (view->lineno == view->lines - 1 &&
1202 view->lines > view->height) {
1203 steps = view->lines - view->offset - 1;
1204 if (steps >= view->height)
1205 steps -= view->height - 1;
1206 }
1207 }
1208
1209 do_scroll_view(view, steps, redraw);
1210 return;
1211 }
1212
1213 /* Draw the current line */
1214 draw_view_line(view, view->lineno - view->offset);
1215
1216 if (!redraw)
1217 return;
1218
1219 redrawwin(view->win);
1220 wrefresh(view->win);
1221 report("");
1222 }
1223
1224
1225 /*
1226 * Incremental updating
1227 */
1228
1229 static void
1230 end_update(struct view *view)
1231 {
1232 if (!view->pipe)
1233 return;
1234 set_nonblocking_input(FALSE);
1235 if (view->pipe == stdin)
1236 fclose(view->pipe);
1237 else
1238 pclose(view->pipe);
1239 view->pipe = NULL;
1240 }
1241
1242 static bool
1243 begin_update(struct view *view)
1244 {
1245 const char *id = view->id;
1246
1247 if (view->pipe)
1248 end_update(view);
1249
1250 if (opt_cmd[0]) {
1251 string_copy(view->cmd, opt_cmd);
1252 opt_cmd[0] = 0;
1253 /* When running random commands, the view ref could have become
1254 * invalid so clear it. */
1255 view->ref[0] = 0;
1256 } else {
1257 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
1258
1259 if (!string_format(view->cmd, format, id, id, id, id, id))
1260 return FALSE;
1261 }
1262
1263 /* Special case for the pager view. */
1264 if (opt_pipe) {
1265 view->pipe = opt_pipe;
1266 opt_pipe = NULL;
1267 } else {
1268 view->pipe = popen(view->cmd, "r");
1269 }
1270
1271 if (!view->pipe)
1272 return FALSE;
1273
1274 set_nonblocking_input(TRUE);
1275
1276 view->offset = 0;
1277 view->lines = 0;
1278 view->lineno = 0;
1279 string_copy(view->vid, id);
1280
1281 if (view->line) {
1282 int i;
1283
1284 for (i = 0; i < view->lines; i++)
1285 if (view->line[i].data)
1286 free(view->line[i].data);
1287
1288 free(view->line);
1289 view->line = NULL;
1290 }
1291
1292 view->start_time = time(NULL);
1293
1294 return TRUE;
1295 }
1296
1297 static struct line *
1298 realloc_lines(struct view *view, size_t line_size)
1299 {
1300 struct line *tmp = realloc(view->line, sizeof(*view->line) * line_size);
1301
1302 if (!tmp)
1303 return NULL;
1304
1305 view->line = tmp;
1306 view->line_size = line_size;
1307 return view->line;
1308 }
1309
1310 static bool
1311 update_view(struct view *view)
1312 {
1313 char buffer[BUFSIZ];
1314 char *line;
1315 /* The number of lines to read. If too low it will cause too much
1316 * redrawing (and possible flickering), if too high responsiveness
1317 * will suffer. */
1318 unsigned long lines = view->height;
1319 int redraw_from = -1;
1320
1321 if (!view->pipe)
1322 return TRUE;
1323
1324 /* Only redraw if lines are visible. */
1325 if (view->offset + view->height >= view->lines)
1326 redraw_from = view->lines - view->offset;
1327
1328 if (!realloc_lines(view, view->lines + lines))
1329 goto alloc_error;
1330
1331 while ((line = fgets(buffer, sizeof(buffer), view->pipe))) {
1332 int linelen = strlen(line);
1333
1334 if (linelen)
1335 line[linelen - 1] = 0;
1336
1337 if (!view->ops->read(view, line))
1338 goto alloc_error;
1339
1340 if (lines-- == 1)
1341 break;
1342 }
1343
1344 {
1345 int digits;
1346
1347 lines = view->lines;
1348 for (digits = 0; lines; digits++)
1349 lines /= 10;
1350
1351 /* Keep the displayed view in sync with line number scaling. */
1352 if (digits != view->digits) {
1353 view->digits = digits;
1354 redraw_from = 0;
1355 }
1356 }
1357
1358 if (redraw_from >= 0) {
1359 /* If this is an incremental update, redraw the previous line
1360 * since for commits some members could have changed when
1361 * loading the main view. */
1362 if (redraw_from > 0)
1363 redraw_from--;
1364
1365 /* Incrementally draw avoids flickering. */
1366 redraw_view_from(view, redraw_from);
1367 }
1368
1369 /* Update the title _after_ the redraw so that if the redraw picks up a
1370 * commit reference in view->ref it'll be available here. */
1371 update_view_title(view);
1372
1373 if (ferror(view->pipe)) {
1374 report("Failed to read: %s", strerror(errno));
1375 goto end;
1376
1377 } else if (feof(view->pipe)) {
1378 report("");
1379 goto end;
1380 }
1381
1382 return TRUE;
1383
1384 alloc_error:
1385 report("Allocation failure");
1386
1387 end:
1388 end_update(view);
1389 return FALSE;
1390 }
1391
1392 enum open_flags {
1393 OPEN_DEFAULT = 0, /* Use default view switching. */
1394 OPEN_SPLIT = 1, /* Split current view. */
1395 OPEN_BACKGROUNDED = 2, /* Backgrounded. */
1396 OPEN_RELOAD = 4, /* Reload view even if it is the current. */
1397 };
1398
1399 static void
1400 open_view(struct view *prev, enum request request, enum open_flags flags)
1401 {
1402 bool backgrounded = !!(flags & OPEN_BACKGROUNDED);
1403 bool split = !!(flags & OPEN_SPLIT);
1404 bool reload = !!(flags & OPEN_RELOAD);
1405 struct view *view = VIEW(request);
1406 int nviews = displayed_views();
1407 struct view *base_view = display[0];
1408
1409 if (view == prev && nviews == 1 && !reload) {
1410 report("Already in %s view", view->name);
1411 return;
1412 }
1413
1414 if (view == VIEW(REQ_VIEW_HELP)) {
1415 load_help_page();
1416
1417 } else if ((reload || strcmp(view->vid, view->id)) &&
1418 !begin_update(view)) {
1419 report("Failed to load %s view", view->name);
1420 return;
1421 }
1422
1423 if (split) {
1424 display[1] = view;
1425 if (!backgrounded)
1426 current_view = 1;
1427 } else {
1428 /* Maximize the current view. */
1429 memset(display, 0, sizeof(display));
1430 current_view = 0;
1431 display[current_view] = view;
1432 }
1433
1434 /* Resize the view when switching between split- and full-screen,
1435 * or when switching between two different full-screen views. */
1436 if (nviews != displayed_views() ||
1437 (nviews == 1 && base_view != display[0]))
1438 resize_display();
1439
1440 if (split && prev->lineno - prev->offset >= prev->height) {
1441 /* Take the title line into account. */
1442 int lines = prev->lineno - prev->offset - prev->height + 1;
1443
1444 /* Scroll the view that was split if the current line is
1445 * outside the new limited view. */
1446 do_scroll_view(prev, lines, TRUE);
1447 }
1448
1449 if (prev && view != prev) {
1450 if (split && !backgrounded) {
1451 /* "Blur" the previous view. */
1452 update_view_title(prev);
1453 }
1454
1455 view->parent = prev;
1456 }
1457
1458 if (view->pipe && view->lines == 0) {
1459 /* Clear the old view and let the incremental updating refill
1460 * the screen. */
1461 wclear(view->win);
1462 report("");
1463 } else {
1464 redraw_view(view);
1465 report("");
1466 }
1467
1468 /* If the view is backgrounded the above calls to report()
1469 * won't redraw the view title. */
1470 if (backgrounded)
1471 update_view_title(view);
1472 }
1473
1474
1475 /*
1476 * User request switch noodle
1477 */
1478
1479 static int
1480 view_driver(struct view *view, enum request request)
1481 {
1482 int i;
1483
1484 switch (request) {
1485 case REQ_MOVE_UP:
1486 case REQ_MOVE_DOWN:
1487 case REQ_MOVE_PAGE_UP:
1488 case REQ_MOVE_PAGE_DOWN:
1489 case REQ_MOVE_FIRST_LINE:
1490 case REQ_MOVE_LAST_LINE:
1491 move_view(view, request, TRUE);
1492 break;
1493
1494 case REQ_SCROLL_LINE_DOWN:
1495 case REQ_SCROLL_LINE_UP:
1496 case REQ_SCROLL_PAGE_DOWN:
1497 case REQ_SCROLL_PAGE_UP:
1498 scroll_view(view, request);
1499 break;
1500
1501 case REQ_VIEW_MAIN:
1502 case REQ_VIEW_DIFF:
1503 case REQ_VIEW_LOG:
1504 case REQ_VIEW_HELP:
1505 case REQ_VIEW_PAGER:
1506 open_view(view, request, OPEN_DEFAULT);
1507 break;
1508
1509 case REQ_NEXT:
1510 case REQ_PREVIOUS:
1511 request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
1512
1513 if (view == VIEW(REQ_VIEW_DIFF) &&
1514 view->parent == VIEW(REQ_VIEW_MAIN)) {
1515 bool redraw = display[1] == view;
1516
1517 view = view->parent;
1518 move_view(view, request, redraw);
1519 if (redraw)
1520 update_view_title(view);
1521 } else {
1522 move_view(view, request, TRUE);
1523 break;
1524 }
1525 /* Fall-through */
1526
1527 case REQ_ENTER:
1528 if (!view->lines) {
1529 report("Nothing to enter");
1530 break;
1531 }
1532 return view->ops->enter(view, &view->line[view->lineno]);
1533
1534 case REQ_VIEW_NEXT:
1535 {
1536 int nviews = displayed_views();
1537 int next_view = (current_view + 1) % nviews;
1538
1539 if (next_view == current_view) {
1540 report("Only one view is displayed");
1541 break;
1542 }
1543
1544 current_view = next_view;
1545 /* Blur out the title of the previous view. */
1546 update_view_title(view);
1547 report("");
1548 break;
1549 }
1550 case REQ_TOGGLE_LINENO:
1551 opt_line_number = !opt_line_number;
1552 redraw_display();
1553 break;
1554
1555 case REQ_TOGGLE_REV_GRAPH:
1556 opt_rev_graph = !opt_rev_graph;
1557 redraw_display();
1558 break;
1559
1560 case REQ_PROMPT:
1561 /* Always reload^Wrerun commands from the prompt. */
1562 open_view(view, opt_request, OPEN_RELOAD);
1563 break;
1564
1565 case REQ_STOP_LOADING:
1566 for (i = 0; i < ARRAY_SIZE(views); i++) {
1567 view = &views[i];
1568 if (view->pipe)
1569 report("Stopped loading the %s view", view->name),
1570 end_update(view);
1571 }
1572 break;
1573
1574 case REQ_SHOW_VERSION:
1575 report("%s (built %s)", VERSION, __DATE__);
1576 return TRUE;
1577
1578 case REQ_SCREEN_RESIZE:
1579 resize_display();
1580 /* Fall-through */
1581 case REQ_SCREEN_REDRAW:
1582 redraw_display();
1583 break;
1584
1585 case REQ_SCREEN_UPDATE:
1586 doupdate();
1587 return TRUE;
1588
1589 case REQ_VIEW_CLOSE:
1590 /* XXX: Mark closed views by letting view->parent point to the
1591 * view itself. Parents to closed view should never be
1592 * followed. */
1593 if (view->parent &&
1594 view->parent->parent != view->parent) {
1595 memset(display, 0, sizeof(display));
1596 current_view = 0;
1597 display[current_view] = view->parent;
1598 view->parent = view;
1599 resize_display();
1600 redraw_display();
1601 break;
1602 }
1603 /* Fall-through */
1604 case REQ_QUIT:
1605 return FALSE;
1606
1607 default:
1608 /* An unknown key will show most commonly used commands. */
1609 report("Unknown key, press 'h' for help");
1610 return TRUE;
1611 }
1612
1613 return TRUE;
1614 }
1615
1616
1617 /*
1618 * Pager backend
1619 */
1620
1621 static bool
1622 pager_draw(struct view *view, struct line *line, unsigned int lineno)
1623 {
1624 char *text = line->data;
1625 enum line_type type = line->type;
1626 int textlen = strlen(text);
1627 int attr;
1628
1629 wmove(view->win, lineno, 0);
1630
1631 if (view->offset + lineno == view->lineno) {
1632 if (type == LINE_COMMIT) {
1633 string_copy(view->ref, text + 7);
1634 string_copy(ref_commit, view->ref);
1635 }
1636
1637 type = LINE_CURSOR;
1638 wchgat(view->win, -1, 0, type, NULL);
1639 }
1640
1641 attr = get_line_attr(type);
1642 wattrset(view->win, attr);
1643
1644 if (opt_line_number || opt_tab_size < TABSIZE) {
1645 static char spaces[] = " ";
1646 int col_offset = 0, col = 0;
1647
1648 if (opt_line_number) {
1649 unsigned long real_lineno = view->offset + lineno + 1;
1650
1651 if (real_lineno == 1 ||
1652 (real_lineno % opt_num_interval) == 0) {
1653 wprintw(view->win, "%.*d", view->digits, real_lineno);
1654
1655 } else {
1656 waddnstr(view->win, spaces,
1657 MIN(view->digits, STRING_SIZE(spaces)));
1658 }
1659 waddstr(view->win, ": ");
1660 col_offset = view->digits + 2;
1661 }
1662
1663 while (text && col_offset + col < view->width) {
1664 int cols_max = view->width - col_offset - col;
1665 char *pos = text;
1666 int cols;
1667
1668 if (*text == '\t') {
1669 text++;
1670 assert(sizeof(spaces) > TABSIZE);
1671 pos = spaces;
1672 cols = opt_tab_size - (col % opt_tab_size);
1673
1674 } else {
1675 text = strchr(text, '\t');
1676 cols = line ? text - pos : strlen(pos);
1677 }
1678
1679 waddnstr(view->win, pos, MIN(cols, cols_max));
1680 col += cols;
1681 }
1682
1683 } else {
1684 int col = 0, pos = 0;
1685
1686 for (; pos < textlen && col < view->width; pos++, col++)
1687 if (text[pos] == '\t')
1688 col += TABSIZE - (col % TABSIZE) - 1;
1689
1690 waddnstr(view->win, text, pos);
1691 }
1692
1693 return TRUE;
1694 }
1695
1696 static void
1697 add_pager_refs(struct view *view, struct line *line)
1698 {
1699 char buf[1024];
1700 char *data = line->data;
1701 struct ref **refs;
1702 int bufpos = 0, refpos = 0;
1703 const char *sep = "Refs: ";
1704
1705 assert(line->type == LINE_COMMIT);
1706
1707 refs = get_refs(data + STRING_SIZE("commit "));
1708 if (!refs)
1709 return;
1710
1711 do {
1712 struct ref *ref = refs[refpos];
1713 char *fmt = ref->tag ? "%s[%s]" : "%s%s";
1714
1715 if (!string_format_from(buf, &bufpos, fmt, sep, ref->name))
1716 return;
1717 sep = ", ";
1718 } while (refs[refpos++]->next);
1719
1720 if (!realloc_lines(view, view->line_size + 1))
1721 return;
1722
1723 line = &view->line[view->lines];
1724 line->data = strdup(buf);
1725 if (!line->data)
1726 return;
1727
1728 line->type = LINE_PP_REFS;
1729 view->lines++;
1730 }
1731
1732 static bool
1733 pager_read(struct view *view, char *data)
1734 {
1735 struct line *line = &view->line[view->lines];
1736
1737 line->data = strdup(data);
1738 if (!line->data)
1739 return FALSE;
1740
1741 line->type = get_line_type(line->data);
1742 view->lines++;
1743
1744 if (line->type == LINE_COMMIT &&
1745 (view == VIEW(REQ_VIEW_DIFF) ||
1746 view == VIEW(REQ_VIEW_LOG)))
1747 add_pager_refs(view, line);
1748
1749 return TRUE;
1750 }
1751
1752 static bool
1753 pager_enter(struct view *view, struct line *line)
1754 {
1755 int split = 0;
1756
1757 if (line->type == LINE_COMMIT &&
1758 (view == VIEW(REQ_VIEW_LOG) ||
1759 view == VIEW(REQ_VIEW_PAGER))) {
1760 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
1761 split = 1;
1762 }
1763
1764 /* Always scroll the view even if it was split. That way
1765 * you can use Enter to scroll through the log view and
1766 * split open each commit diff. */
1767 scroll_view(view, REQ_SCROLL_LINE_DOWN);
1768
1769 /* FIXME: A minor workaround. Scrolling the view will call report("")
1770 * but if we are scrolling a non-current view this won't properly
1771 * update the view title. */
1772 if (split)
1773 update_view_title(view);
1774
1775 return TRUE;
1776 }
1777
1778 static struct view_ops pager_ops = {
1779 "line",
1780 pager_draw,
1781 pager_read,
1782 pager_enter,
1783 };
1784
1785
1786 /*
1787 * Main view backend
1788 */
1789
1790 struct commit {
1791 char id[41]; /* SHA1 ID. */
1792 char title[75]; /* First line of the commit message. */
1793 char author[75]; /* Author of the commit. */
1794 struct tm time; /* Date from the author ident. */
1795 struct ref **refs; /* Repository references. */
1796 chtype graph[SIZEOF_REVGRAPH]; /* Ancestry chain graphics. */
1797 size_t graph_size; /* The width of the graph array. */
1798 };
1799
1800 static bool
1801 main_draw(struct view *view, struct line *line, unsigned int lineno)
1802 {
1803 char buf[DATE_COLS + 1];
1804 struct commit *commit = line->data;
1805 enum line_type type;
1806 int col = 0;
1807 size_t timelen;
1808 size_t authorlen;
1809 int trimmed = 1;
1810
1811 if (!*commit->author)
1812 return FALSE;
1813
1814 wmove(view->win, lineno, col);
1815
1816 if (view->offset + lineno == view->lineno) {
1817 string_copy(view->ref, commit->id);
1818 string_copy(ref_commit, view->ref);
1819 type = LINE_CURSOR;
1820 wattrset(view->win, get_line_attr(type));
1821 wchgat(view->win, -1, 0, type, NULL);
1822
1823 } else {
1824 type = LINE_MAIN_COMMIT;
1825 wattrset(view->win, get_line_attr(LINE_MAIN_DATE));
1826 }
1827
1828 timelen = strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time);
1829 waddnstr(view->win, buf, timelen);
1830 waddstr(view->win, " ");
1831
1832 col += DATE_COLS;
1833 wmove(view->win, lineno, col);
1834 if (type != LINE_CURSOR)
1835 wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
1836
1837 if (opt_utf8) {
1838 authorlen = utf8_length(commit->author, AUTHOR_COLS - 2, &col, &trimmed);
1839 } else {
1840 authorlen = strlen(commit->author);
1841 if (authorlen > AUTHOR_COLS - 2) {
1842 authorlen = AUTHOR_COLS - 2;
1843 trimmed = 1;
1844 }
1845 }
1846
1847 if (trimmed) {
1848 waddnstr(view->win, commit->author, authorlen);
1849 if (type != LINE_CURSOR)
1850 wattrset(view->win, get_line_attr(LINE_MAIN_DELIM));
1851 waddch(view->win, '~');
1852 } else {
1853 waddstr(view->win, commit->author);
1854 }
1855
1856 col += AUTHOR_COLS;
1857 if (type != LINE_CURSOR)
1858 wattrset(view->win, A_NORMAL);
1859
1860 if (opt_rev_graph && commit->graph_size) {
1861 size_t i;
1862
1863 wmove(view->win, lineno, col);
1864 /* Using waddch() instead of waddnstr() ensures that
1865 * they'll be rendered correctly for the cursor line. */
1866 for (i = 0; i < commit->graph_size; i++)
1867 waddch(view->win, commit->graph[i]);
1868
1869 col += commit->graph_size + 1;
1870 }
1871
1872 wmove(view->win, lineno, col);
1873
1874 if (commit->refs) {
1875 size_t i = 0;
1876
1877 do {
1878 if (type == LINE_CURSOR)
1879 ;
1880 else if (commit->refs[i]->tag)
1881 wattrset(view->win, get_line_attr(LINE_MAIN_TAG));
1882 else
1883 wattrset(view->win, get_line_attr(LINE_MAIN_REF));
1884 waddstr(view->win, "[");
1885 waddstr(view->win, commit->refs[i]->name);
1886 waddstr(view->win, "]");
1887 if (type != LINE_CURSOR)
1888 wattrset(view->win, A_NORMAL);
1889 waddstr(view->win, " ");
1890 col += strlen(commit->refs[i]->name) + STRING_SIZE("[] ");
1891 } while (commit->refs[i++]->next);
1892 }
1893
1894 if (type != LINE_CURSOR)
1895 wattrset(view->win, get_line_attr(type));
1896
1897 {
1898 int titlelen = strlen(commit->title);
1899
1900 if (col + titlelen > view->width)
1901 titlelen = view->width - col;
1902
1903 waddnstr(view->win, commit->title, titlelen);
1904 }
1905
1906 return TRUE;
1907 }
1908
1909 /* Reads git log --pretty=raw output and parses it into the commit struct. */
1910 static bool
1911 main_read(struct view *view, char *line)
1912 {
1913 enum line_type type = get_line_type(line);
1914 struct commit *commit = view->lines
1915 ? view->line[view->lines - 1].data : NULL;
1916
1917 switch (type) {
1918 case LINE_COMMIT:
1919 commit = calloc(1, sizeof(struct commit));
1920 if (!commit)
1921 return FALSE;
1922
1923 line += STRING_SIZE("commit ");
1924
1925 view->line[view->lines++].data = commit;
1926 string_copy(commit->id, line);
1927 commit->refs = get_refs(commit->id);
1928 commit->graph[commit->graph_size++] = ACS_LTEE;
1929 break;
1930
1931 case LINE_AUTHOR:
1932 {
1933 char *ident = line + STRING_SIZE("author ");
1934 char *end = strchr(ident, '<');
1935
1936 if (!commit)
1937 break;
1938
1939 if (end) {
1940 for (; end > ident && isspace(end[-1]); end--) ;
1941 *end = 0;
1942 }
1943
1944 string_copy(commit->author, ident);
1945
1946 /* Parse epoch and timezone */
1947 if (end) {
1948 char *secs = strchr(end + 1, '>');
1949 char *zone;
1950 time_t time;
1951
1952 if (!secs || secs[1] != ' ')
1953 break;
1954
1955 secs += 2;
1956 time = (time_t) atol(secs);
1957 zone = strchr(secs, ' ');
1958 if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
1959 long tz;
1960
1961 zone++;
1962 tz = ('0' - zone[1]) * 60 * 60 * 10;
1963 tz += ('0' - zone[2]) * 60 * 60;
1964 tz += ('0' - zone[3]) * 60;
1965 tz += ('0' - zone[4]) * 60;
1966
1967 if (zone[0] == '-')
1968 tz = -tz;
1969
1970 time -= tz;
1971 }
1972 gmtime_r(&time, &commit->time);
1973 }
1974 break;
1975 }
1976 default:
1977 if (!commit)
1978 break;
1979
1980 /* Fill in the commit title if it has not already been set. */
1981 if (commit->title[0])
1982 break;
1983
1984 /* Require titles to start with a non-space character at the
1985 * offset used by git log. */
1986 /* FIXME: More gracefull handling of titles; append "..." to
1987 * shortened titles, etc. */
1988 if (strncmp(line, " ", 4) ||
1989 isspace(line[4]))
1990 break;
1991
1992 string_copy(commit->title, line + 4);
1993 }
1994
1995 return TRUE;
1996 }
1997
1998 static bool
1999 main_enter(struct view *view, struct line *line)
2000 {
2001 enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
2002
2003 open_view(view, REQ_VIEW_DIFF, flags);
2004 return TRUE;
2005 }
2006
2007 static struct view_ops main_ops = {
2008 "commit",
2009 main_draw,
2010 main_read,
2011 main_enter,
2012 };
2013
2014
2015 /*
2016 * Keys
2017 */
2018
2019 struct keymap {
2020 int alias;
2021 int request;
2022 };
2023
2024 static struct keymap keymap[] = {
2025 /* View switching */
2026 { 'm', REQ_VIEW_MAIN },
2027 { 'd', REQ_VIEW_DIFF },
2028 { 'l', REQ_VIEW_LOG },
2029 { 'p', REQ_VIEW_PAGER },
2030 { 'h', REQ_VIEW_HELP },
2031 { '?', REQ_VIEW_HELP },
2032
2033 /* View manipulation */
2034 { 'q', REQ_VIEW_CLOSE },
2035 { KEY_TAB, REQ_VIEW_NEXT },
2036 { KEY_RETURN, REQ_ENTER },
2037 { KEY_UP, REQ_PREVIOUS },
2038 { KEY_DOWN, REQ_NEXT },
2039
2040 /* Cursor navigation */
2041 { 'k', REQ_MOVE_UP },
2042 { 'j', REQ_MOVE_DOWN },
2043 { KEY_HOME, REQ_MOVE_FIRST_LINE },
2044 { KEY_END, REQ_MOVE_LAST_LINE },
2045 { KEY_NPAGE, REQ_MOVE_PAGE_DOWN },
2046 { ' ', REQ_MOVE_PAGE_DOWN },
2047 { KEY_PPAGE, REQ_MOVE_PAGE_UP },
2048 { 'b', REQ_MOVE_PAGE_UP },
2049 { '-', REQ_MOVE_PAGE_UP },
2050
2051 /* Scrolling */
2052 { KEY_IC, REQ_SCROLL_LINE_UP },
2053 { KEY_DC, REQ_SCROLL_LINE_DOWN },
2054 { 'w', REQ_SCROLL_PAGE_UP },
2055 { 's', REQ_SCROLL_PAGE_DOWN },
2056
2057 /* Misc */
2058 { 'Q', REQ_QUIT },
2059 { 'z', REQ_STOP_LOADING },
2060 { 'v', REQ_SHOW_VERSION },
2061 { 'r', REQ_SCREEN_REDRAW },
2062 { 'n', REQ_TOGGLE_LINENO },
2063 { 'g', REQ_TOGGLE_REV_GRAPH},
2064 { ':', REQ_PROMPT },
2065
2066 /* wgetch() with nodelay() enabled returns ERR when there's no input. */
2067 { ERR, REQ_SCREEN_UPDATE },
2068
2069 /* Use the ncurses SIGWINCH handler. */
2070 { KEY_RESIZE, REQ_SCREEN_RESIZE },
2071 };
2072
2073 static enum request
2074 get_request(int key)
2075 {
2076 int i;
2077
2078 for (i = 0; i < ARRAY_SIZE(keymap); i++)
2079 if (keymap[i].alias == key)
2080 return keymap[i].request;
2081
2082 return (enum request) key;
2083 }
2084
2085 struct key {
2086 char *name;
2087 int value;
2088 };
2089
2090 static struct key key_table[] = {
2091 { "Enter", KEY_RETURN },
2092 { "Space", ' ' },
2093 { "Backspace", KEY_BACKSPACE },
2094 { "Tab", KEY_TAB },
2095 { "Escape", KEY_ESC },
2096 { "Left", KEY_LEFT },
2097 { "Right", KEY_RIGHT },
2098 { "Up", KEY_UP },
2099 { "Down", KEY_DOWN },
2100 { "Insert", KEY_IC },
2101 { "Delete", KEY_DC },
2102 { "Home", KEY_HOME },
2103 { "End", KEY_END },
2104 { "PageUp", KEY_PPAGE },
2105 { "PageDown", KEY_NPAGE },
2106 { "F1", KEY_F(1) },
2107 { "F2", KEY_F(2) },
2108 { "F3", KEY_F(3) },
2109 { "F4", KEY_F(4) },
2110 { "F5", KEY_F(5) },
2111 { "F6", KEY_F(6) },
2112 { "F7", KEY_F(7) },
2113 { "F8", KEY_F(8) },
2114 { "F9", KEY_F(9) },
2115 { "F10", KEY_F(10) },
2116 { "F11", KEY_F(11) },
2117 { "F12", KEY_F(12) },
2118 };
2119
2120 static char *
2121 get_key(enum request request)
2122 {
2123 static char buf[BUFSIZ];
2124 static char key_char[] = "'X'";
2125 int pos = 0;
2126 char *sep = " ";
2127 int i;
2128
2129 buf[pos] = 0;
2130
2131 for (i = 0; i < ARRAY_SIZE(keymap); i++) {
2132 char *seq = NULL;
2133 int key;
2134
2135 if (keymap[i].request != request)
2136 continue;
2137
2138 for (key = 0; key < ARRAY_SIZE(key_table); key++)
2139 if (key_table[key].value == keymap[i].alias)
2140 seq = key_table[key].name;
2141
2142 if (seq == NULL &&
2143 keymap[i].alias < 127 &&
2144 isprint(keymap[i].alias)) {
2145 key_char[1] = (char) keymap[i].alias;
2146 seq = key_char;
2147 }
2148
2149 if (!seq)
2150 seq = "'?'";
2151
2152 if (!string_format_from(buf, &pos, "%s%s", sep, seq))
2153 return "Too many keybindings!";
2154 sep = ", ";
2155 }
2156
2157 return buf;
2158 }
2159
2160 static void load_help_page(void)
2161 {
2162 char buf[BUFSIZ];
2163 struct view *view = VIEW(REQ_VIEW_HELP);
2164 int lines = ARRAY_SIZE(req_info) + 2;
2165 int i;
2166
2167 if (view->lines > 0)
2168 return;
2169
2170 for (i = 0; i < ARRAY_SIZE(req_info); i++)
2171 if (!req_info[i].request)
2172 lines++;
2173
2174 view->line = calloc(lines, sizeof(*view->line));
2175 if (!view->line) {
2176 report("Allocation failure");
2177 return;
2178 }
2179
2180 pager_read(view, "Quick reference for tig keybindings:");
2181
2182 for (i = 0; i < ARRAY_SIZE(req_info); i++) {
2183 char *key;
2184
2185 if (!req_info[i].request) {
2186 pager_read(view, "");
2187 pager_read(view, req_info[i].help);
2188 continue;
2189 }
2190
2191 key = get_key(req_info[i].request);
2192 if (!string_format(buf, "%-25s %s", key, req_info[i].help))
2193 continue;
2194
2195 pager_read(view, buf);
2196 }
2197 }
2198
2199
2200 /*
2201 * Unicode / UTF-8 handling
2202 *
2203 * NOTE: Much of the following code for dealing with unicode is derived from
2204 * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
2205 * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
2206 */
2207
2208 /* I've (over)annotated a lot of code snippets because I am not entirely
2209 * confident that the approach taken by this small UTF-8 interface is correct.
2210 * --jonas */
2211
2212 static inline int
2213 unicode_width(unsigned long c)
2214 {
2215 if (c >= 0x1100 &&
2216 (c <= 0x115f /* Hangul Jamo */
2217 || c == 0x2329
2218 || c == 0x232a
2219 || (c >= 0x2e80 && c <= 0xa4cf && c != 0x303f)
2220 /* CJK ... Yi */
2221 || (c >= 0xac00 && c <= 0xd7a3) /* Hangul Syllables */
2222 || (c >= 0xf900 && c <= 0xfaff) /* CJK Compatibility Ideographs */
2223 || (c >= 0xfe30 && c <= 0xfe6f) /* CJK Compatibility Forms */
2224 || (c >= 0xff00 && c <= 0xff60) /* Fullwidth Forms */
2225 || (c >= 0xffe0 && c <= 0xffe6)
2226 || (c >= 0x20000 && c <= 0x2fffd)
2227 || (c >= 0x30000 && c <= 0x3fffd)))
2228 return 2;
2229
2230 return 1;
2231 }
2232
2233 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
2234 * Illegal bytes are set one. */
2235 static const unsigned char utf8_bytes[256] = {
2236 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,
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 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,
2243 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,
2244 };
2245
2246 /* Decode UTF-8 multi-byte representation into a unicode character. */
2247 static inline unsigned long
2248 utf8_to_unicode(const char *string, size_t length)
2249 {
2250 unsigned long unicode;
2251
2252 switch (length) {
2253 case 1:
2254 unicode = string[0];
2255 break;
2256 case 2:
2257 unicode = (string[0] & 0x1f) << 6;
2258 unicode += (string[1] & 0x3f);
2259 break;
2260 case 3:
2261 unicode = (string[0] & 0x0f) << 12;
2262 unicode += ((string[1] & 0x3f) << 6);
2263 unicode += (string[2] & 0x3f);
2264 break;
2265 case 4:
2266 unicode = (string[0] & 0x0f) << 18;
2267 unicode += ((string[1] & 0x3f) << 12);
2268 unicode += ((string[2] & 0x3f) << 6);
2269 unicode += (string[3] & 0x3f);
2270 break;
2271 case 5:
2272 unicode = (string[0] & 0x0f) << 24;
2273 unicode += ((string[1] & 0x3f) << 18);
2274 unicode += ((string[2] & 0x3f) << 12);
2275 unicode += ((string[3] & 0x3f) << 6);
2276 unicode += (string[4] & 0x3f);
2277 break;
2278 case 6:
2279 unicode = (string[0] & 0x01) << 30;
2280 unicode += ((string[1] & 0x3f) << 24);
2281 unicode += ((string[2] & 0x3f) << 18);
2282 unicode += ((string[3] & 0x3f) << 12);
2283 unicode += ((string[4] & 0x3f) << 6);
2284 unicode += (string[5] & 0x3f);
2285 break;
2286 default:
2287 die("Invalid unicode length");
2288 }
2289
2290 /* Invalid characters could return the special 0xfffd value but NUL
2291 * should be just as good. */
2292 return unicode > 0xffff ? 0 : unicode;
2293 }
2294
2295 /* Calculates how much of string can be shown within the given maximum width
2296 * and sets trimmed parameter to non-zero value if all of string could not be
2297 * shown.
2298 *
2299 * Additionally, adds to coloffset how many many columns to move to align with
2300 * the expected position. Takes into account how multi-byte and double-width
2301 * characters will effect the cursor position.
2302 *
2303 * Returns the number of bytes to output from string to satisfy max_width. */
2304 static size_t
2305 utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed)
2306 {
2307 const char *start = string;
2308 const char *end = strchr(string, '\0');
2309 size_t mbwidth = 0;
2310 size_t width = 0;
2311
2312 *trimmed = 0;
2313
2314 while (string < end) {
2315 int c = *(unsigned char *) string;
2316 unsigned char bytes = utf8_bytes[c];
2317 size_t ucwidth;
2318 unsigned long unicode;
2319
2320 if (string + bytes > end)
2321 break;
2322
2323 /* Change representation to figure out whether
2324 * it is a single- or double-width character. */
2325
2326 unicode = utf8_to_unicode(string, bytes);
2327 /* FIXME: Graceful handling of invalid unicode character. */
2328 if (!unicode)
2329 break;
2330
2331 ucwidth = unicode_width(unicode);
2332 width += ucwidth;
2333 if (width > max_width) {
2334 *trimmed = 1;
2335 break;
2336 }
2337
2338 /* The column offset collects the differences between the
2339 * number of bytes encoding a character and the number of
2340 * columns will be used for rendering said character.
2341 *
2342 * So if some character A is encoded in 2 bytes, but will be
2343 * represented on the screen using only 1 byte this will and up
2344 * adding 1 to the multi-byte column offset.
2345 *
2346 * Assumes that no double-width character can be encoding in
2347 * less than two bytes. */
2348 if (bytes > ucwidth)
2349 mbwidth += bytes - ucwidth;
2350
2351 string += bytes;
2352 }
2353
2354 *coloffset += mbwidth;
2355
2356 return string - start;
2357 }
2358
2359
2360 /*
2361 * Status management
2362 */
2363
2364 /* Whether or not the curses interface has been initialized. */
2365 static bool cursed = FALSE;
2366
2367 /* The status window is used for polling keystrokes. */
2368 static WINDOW *status_win;
2369
2370 /* Update status and title window. */
2371 static void
2372 report(const char *msg, ...)
2373 {
2374 static bool empty = TRUE;
2375 struct view *view = display[current_view];
2376
2377 if (!empty || *msg) {
2378 va_list args;
2379
2380 va_start(args, msg);
2381
2382 werase(status_win);
2383 wmove(status_win, 0, 0);
2384 if (*msg) {
2385 vwprintw(status_win, msg, args);
2386 empty = FALSE;
2387 } else {
2388 empty = TRUE;
2389 }
2390 wrefresh(status_win);
2391
2392 va_end(args);
2393 }
2394
2395 update_view_title(view);
2396 update_display_cursor();
2397 }
2398
2399 /* Controls when nodelay should be in effect when polling user input. */
2400 static void
2401 set_nonblocking_input(bool loading)
2402 {
2403 static unsigned int loading_views;
2404
2405 if ((loading == FALSE && loading_views-- == 1) ||
2406 (loading == TRUE && loading_views++ == 0))
2407 nodelay(status_win, loading);
2408 }
2409
2410 static void
2411 init_display(void)
2412 {
2413 int x, y;
2414
2415 /* Initialize the curses library */
2416 if (isatty(STDIN_FILENO)) {
2417 cursed = !!initscr();
2418 } else {
2419 /* Leave stdin and stdout alone when acting as a pager. */
2420 FILE *io = fopen("/dev/tty", "r+");
2421
2422 cursed = !!newterm(NULL, io, io);
2423 }
2424
2425 if (!cursed)
2426 die("Failed to initialize curses");
2427
2428 nonl(); /* Tell curses not to do NL->CR/NL on output */
2429 cbreak(); /* Take input chars one at a time, no wait for \n */
2430 noecho(); /* Don't echo input */
2431 leaveok(stdscr, TRUE);
2432
2433 if (has_colors())
2434 init_colors();
2435
2436 getmaxyx(stdscr, y, x);
2437 status_win = newwin(1, 0, y - 1, 0);
2438 if (!status_win)
2439 die("Failed to create status window");
2440
2441 /* Enable keyboard mapping */
2442 keypad(status_win, TRUE);
2443 wbkgdset(status_win, get_line_attr(LINE_STATUS));
2444 }
2445
2446
2447 /*
2448 * Repository references
2449 */
2450
2451 static struct ref *refs;
2452 static size_t refs_size;
2453
2454 /* Id <-> ref store */
2455 static struct ref ***id_refs;
2456 static size_t id_refs_size;
2457
2458 static struct ref **
2459 get_refs(char *id)
2460 {
2461 struct ref ***tmp_id_refs;
2462 struct ref **ref_list = NULL;
2463 size_t ref_list_size = 0;
2464 size_t i;
2465
2466 for (i = 0; i < id_refs_size; i++)
2467 if (!strcmp(id, id_refs[i][0]->id))
2468 return id_refs[i];
2469
2470 tmp_id_refs = realloc(id_refs, (id_refs_size + 1) * sizeof(*id_refs));
2471 if (!tmp_id_refs)
2472 return NULL;
2473
2474 id_refs = tmp_id_refs;
2475
2476 for (i = 0; i < refs_size; i++) {
2477 struct ref **tmp;
2478
2479 if (strcmp(id, refs[i].id))
2480 continue;
2481
2482 tmp = realloc(ref_list, (ref_list_size + 1) * sizeof(*ref_list));
2483 if (!tmp) {
2484 if (ref_list)
2485 free(ref_list);
2486 return NULL;
2487 }
2488
2489 ref_list = tmp;
2490 if (ref_list_size > 0)
2491 ref_list[ref_list_size - 1]->next = 1;
2492 ref_list[ref_list_size] = &refs[i];
2493
2494 /* XXX: The properties of the commit chains ensures that we can
2495 * safely modify the shared ref. The repo references will
2496 * always be similar for the same id. */
2497 ref_list[ref_list_size]->next = 0;
2498 ref_list_size++;
2499 }
2500
2501 if (ref_list)
2502 id_refs[id_refs_size++] = ref_list;
2503
2504 return ref_list;
2505 }
2506
2507 static int
2508 read_ref(char *id, int idlen, char *name, int namelen)
2509 {
2510 struct ref *ref;
2511 bool tag = FALSE;
2512
2513 if (!strncmp(name, "refs/tags/", STRING_SIZE("refs/tags/"))) {
2514 /* Commits referenced by tags has "^{}" appended. */
2515 if (name[namelen - 1] != '}')
2516 return OK;
2517
2518 while (namelen > 0 && name[namelen] != '^')
2519 namelen--;
2520
2521 tag = TRUE;
2522 namelen -= STRING_SIZE("refs/tags/");
2523 name += STRING_SIZE("refs/tags/");
2524
2525 } else if (!strncmp(name, "refs/heads/", STRING_SIZE("refs/heads/"))) {
2526 namelen -= STRING_SIZE("refs/heads/");
2527 name += STRING_SIZE("refs/heads/");
2528
2529 } else if (!strcmp(name, "HEAD")) {
2530 return OK;
2531 }
2532
2533 refs = realloc(refs, sizeof(*refs) * (refs_size + 1));
2534 if (!refs)
2535 return ERR;
2536
2537 ref = &refs[refs_size++];
2538 ref->name = malloc(namelen + 1);
2539 if (!ref->name)
2540 return ERR;
2541
2542 strncpy(ref->name, name, namelen);
2543 ref->name[namelen] = 0;
2544 ref->tag = tag;
2545 string_copy(ref->id, id);
2546
2547 return OK;
2548 }
2549
2550 static int
2551 load_refs(void)
2552 {
2553 const char *cmd_env = getenv("TIG_LS_REMOTE");
2554 const char *cmd = cmd_env && *cmd_env ? cmd_env : TIG_LS_REMOTE;
2555
2556 return read_properties(popen(cmd, "r"), "\t", read_ref);
2557 }
2558
2559 static int
2560 read_repo_config_option(char *name, int namelen, char *value, int valuelen)
2561 {
2562 if (!strcmp(name, "i18n.commitencoding"))
2563 string_copy(opt_encoding, value);
2564
2565 return OK;
2566 }
2567
2568 static int
2569 load_repo_config(void)
2570 {
2571 return read_properties(popen("git repo-config --list", "r"),
2572 "=", read_repo_config_option);
2573 }
2574
2575 static int
2576 read_properties(FILE *pipe, const char *separators,
2577 int (*read_property)(char *, int, char *, int))
2578 {
2579 char buffer[BUFSIZ];
2580 char *name;
2581 int state = OK;
2582
2583 if (!pipe)
2584 return ERR;
2585
2586 while (state == OK && (name = fgets(buffer, sizeof(buffer), pipe))) {
2587 char *value;
2588 size_t namelen;
2589 size_t valuelen;
2590
2591 name = chomp_string(name);
2592 namelen = strcspn(name, separators);
2593
2594 if (name[namelen]) {
2595 name[namelen] = 0;
2596 value = chomp_string(name + namelen + 1);
2597 valuelen = strlen(value);
2598
2599 } else {
2600 value = "";
2601 valuelen = 0;
2602 }
2603
2604 state = read_property(name, namelen, value, valuelen);
2605 }
2606
2607 if (state != ERR && ferror(pipe))
2608 state = ERR;
2609
2610 pclose(pipe);
2611
2612 return state;
2613 }
2614
2615
2616 /*
2617 * Main
2618 */
2619
2620 static void __NORETURN
2621 quit(int sig)
2622 {
2623 /* XXX: Restore tty modes and let the OS cleanup the rest! */
2624 if (cursed)
2625 endwin();
2626 exit(0);
2627 }
2628
2629 static void __NORETURN
2630 die(const char *err, ...)
2631 {
2632 va_list args;
2633
2634 endwin();
2635
2636 va_start(args, err);
2637 fputs("tig: ", stderr);
2638 vfprintf(stderr, err, args);
2639 fputs("\n", stderr);
2640 va_end(args);
2641
2642 exit(1);
2643 }
2644
2645 int
2646 main(int argc, char *argv[])
2647 {
2648 struct view *view;
2649 enum request request;
2650 size_t i;
2651
2652 signal(SIGINT, quit);
2653
2654 if (load_options() == ERR)
2655 die("Failed to load user config.");
2656
2657 /* Load the repo config file so options can be overwritten from
2658 * the command line. */
2659 if (load_repo_config() == ERR)
2660 die("Failed to load repo config.");
2661
2662 if (!parse_options(argc, argv))
2663 return 0;
2664
2665 if (load_refs() == ERR)
2666 die("Failed to load refs.");
2667
2668 /* Require a git repository unless when running in pager mode. */
2669 if (refs_size == 0 && opt_request != REQ_VIEW_PAGER)
2670 die("Not a git repository");
2671
2672 for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
2673 view->cmd_env = getenv(view->cmd_env);
2674
2675 request = opt_request;
2676
2677 init_display();
2678
2679 while (view_driver(display[current_view], request)) {
2680 int key;
2681 int i;
2682
2683 foreach_view (view, i)
2684 update_view(view);
2685
2686 /* Refresh, accept single keystroke of input */
2687 key = wgetch(status_win);
2688 request = get_request(key);
2689
2690 /* Some low-level request handling. This keeps access to
2691 * status_win restricted. */
2692 switch (request) {
2693 case REQ_PROMPT:
2694 report(":");
2695 /* Temporarily switch to line-oriented and echoed
2696 * input. */
2697 nocbreak();
2698 echo();
2699
2700 if (wgetnstr(status_win, opt_cmd + 4, sizeof(opt_cmd) - 4) == OK) {
2701 memcpy(opt_cmd, "git ", 4);
2702 opt_request = REQ_VIEW_PAGER;
2703 } else {
2704 report("Prompt interrupted by loading view, "
2705 "press 'z' to stop loading views");
2706 request = REQ_SCREEN_UPDATE;
2707 }
2708
2709 noecho();
2710 cbreak();
2711 break;
2712
2713 case REQ_SCREEN_RESIZE:
2714 {
2715 int height, width;
2716
2717 getmaxyx(stdscr, height, width);
2718
2719 /* Resize the status view and let the view driver take
2720 * care of resizing the displayed views. */
2721 wresize(status_win, 1, width);
2722 mvwin(status_win, height - 1, 0);
2723 wrefresh(status_win);
2724 break;
2725 }
2726 default:
2727 break;
2728 }
2729 }
2730
2731 quit(0);
2732
2733 return 0;
2734 }
Full-screen terminal Git browser.