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