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