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