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