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.6.git"
  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 <sys/types.h>
  34 #include <regex.h>
  35
  36 #include <locale.h>
  37 #include <langinfo.h>
  38 #include <iconv.h>
  39
  40 #include <curses.h>
  41
  42 #if __GNUC__ >= 3
  43 #define __NORETURN __attribute__((__noreturn__))
  44 #else
  45 #define __NORETURN
  46 #endif
  47
  48 static void __NORETURN die(const char *err, ...);
  49 static void report(const char *msg, ...);
  50 static int read_properties(FILE *pipe, const char *separators, int (*read)(char *, int, char *, int));
  51 static void set_nonblocking_input(bool loading);
  52 static size_t utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed);
  53
  54 #define ABS(x)          ((x) >= 0  ? (x) : -(x))
  55 #define MIN(x, y)       ((x) < (y) ? (x) :  (y))
  56
  57 #define ARRAY_SIZE(x)   (sizeof(x) / sizeof(x[0]))
  58 #define STRING_SIZE(x)  (sizeof(x) - 1)
  59
  60 #define SIZEOF_STR      1024    /* Default string size. */
  61 #define SIZEOF_REF      256     /* Size of symbolic or SHA1 ID. */
  62 #define SIZEOF_REV      41      /* Holds a SHA-1 and an ending NUL */
  63
  64 /* Revision graph */
  65
  66 #define REVGRAPH_INIT   'I'
  67 #define REVGRAPH_MERGE  'M'
  68 #define REVGRAPH_BRANCH '+'
  69 #define REVGRAPH_COMMIT '*'
  70 #define REVGRAPH_LINE   '|'
  71
  72 #define SIZEOF_REVGRAPH 19      /* Size of revision ancestry graphics. */
  73
  74 /* This color name can be used to refer to the default term colors. */
  75 #define COLOR_DEFAULT   (-1)
  76
  77 #define ICONV_NONE      ((iconv_t) -1)
  78
  79 /* The format and size of the date column in the main view. */
  80 #define DATE_FORMAT     "%Y-%m-%d %H:%M"
  81 #define DATE_COLS       STRING_SIZE("2006-04-29 14:21 ")
  82
  83 #define AUTHOR_COLS     20
  84
  85 /* The default interval between line numbers. */
  86 #define NUMBER_INTERVAL 1
  87
  88 #define TABSIZE         8
  89
  90 #define SCALE_SPLIT_VIEW(height)        ((height) * 2 / 3)
  91
  92 #define TIG_LS_REMOTE \
  93         "git ls-remote $(git rev-parse --git-dir) 2>/dev/null"
  94
  95 #define TIG_DIFF_CMD \
  96         "git show --root --patch-with-stat --find-copies-harder -B -C %s 2>/dev/null"
  97
  98 #define TIG_LOG_CMD     \
  99         "git log --cc --stat -n100 %s 2>/dev/null"
 100
 101 #define TIG_MAIN_CMD \
 102         "git log --topo-order --pretty=raw %s 2>/dev/null"
 103
 104 #define TIG_TREE_CMD    \
 105         "git ls-tree %s %s"
 106
 107 #define TIG_BLOB_CMD    \
 108         "git cat-file blob %s"
 109
 110 /* XXX: Needs to be defined to the empty string. */
 111 #define TIG_HELP_CMD    ""
 112 #define TIG_PAGER_CMD   ""
 113
 114 /* Some ascii-shorthands fitted into the ncurses namespace. */
 115 #define KEY_TAB         '\t'
 116 #define KEY_RETURN      '\r'
 117 #define KEY_ESC         27
 118
 119
 120 struct ref {
 121         char *name;             /* Ref name; tag or head names are shortened. */
 122         char id[SIZEOF_REV];    /* Commit SHA1 ID */
 123         unsigned int tag:1;     /* Is it a tag? */
 124         unsigned int remote:1;  /* Is it a remote ref? */
 125         unsigned int next:1;    /* For ref lists: are there more refs? */
 126 };
 127
 128 static struct ref **get_refs(char *id);
 129
 130 struct int_map {
 131         const char *name;
 132         int namelen;
 133         int value;
 134 };
 135
 136 static int
 137 set_from_int_map(struct int_map *map, size_t map_size,
 138                  int *value, const char *name, int namelen)
 139 {
 140
 141         int i;
 142
 143         for (i = 0; i < map_size; i++)
 144                 if (namelen == map[i].namelen &&
 145                     !strncasecmp(name, map[i].name, namelen)) {
 146                         *value = map[i].value;
 147                         return OK;
 148                 }
 149
 150         return ERR;
 151 }
 152
 153
 154 /*
 155  * String helpers
 156  */
 157
 158 static inline void
 159 string_ncopy_do(char *dst, size_t dstlen, const char *src, size_t srclen)
 160 {
 161         if (srclen > dstlen - 1)
 162                 srclen = dstlen - 1;
 163
 164         strncpy(dst, src, srclen);
 165         dst[srclen] = 0;
 166 }
 167
 168 /* Shorthands for safely copying into a fixed buffer. */
 169
 170 #define string_copy(dst, src) \
 171         string_ncopy_do(dst, sizeof(dst), src, sizeof(dst))
 172
 173 #define string_ncopy(dst, src, srclen) \
 174         string_ncopy_do(dst, sizeof(dst), src, srclen)
 175
 176 static char *
 177 chomp_string(char *name)
 178 {
 179         int namelen;
 180
 181         while (isspace(*name))
 182                 name++;
 183
 184         namelen = strlen(name) - 1;
 185         while (namelen > 0 && isspace(name[namelen]))
 186                 name[namelen--] = 0;
 187
 188         return name;
 189 }
 190
 191 static bool
 192 string_nformat(char *buf, size_t bufsize, size_t *bufpos, const char *fmt, ...)
 193 {
 194         va_list args;
 195         size_t pos = bufpos ? *bufpos : 0;
 196
 197         va_start(args, fmt);
 198         pos += vsnprintf(buf + pos, bufsize - pos, fmt, args);
 199         va_end(args);
 200
 201         if (bufpos)
 202                 *bufpos = pos;
 203
 204         return pos >= bufsize ? FALSE : TRUE;
 205 }
 206
 207 #define string_format(buf, fmt, args...) \
 208         string_nformat(buf, sizeof(buf), NULL, fmt, args)
 209
 210 #define string_format_from(buf, from, fmt, args...) \
 211         string_nformat(buf, sizeof(buf), from, fmt, args)
 212
 213 static int
 214 string_enum_compare(const char *str1, const char *str2, int len)
 215 {
 216         size_t i;
 217
 218 #define string_enum_sep(x) ((x) == '-' || (x) == '_' || (x) == '.')
 219
 220         /* Diff-Header == DIFF_HEADER */
 221         for (i = 0; i < len; i++) {
 222                 if (toupper(str1[i]) == toupper(str2[i]))
 223                         continue;
 224
 225                 if (string_enum_sep(str1[i]) &&
 226                     string_enum_sep(str2[i]))
 227                         continue;
 228
 229                 return str1[i] - str2[i];
 230         }
 231
 232         return 0;
 233 }
 234
 235 /* Shell quoting
 236  *
 237  * NOTE: The following is a slightly modified copy of the git project's shell
 238  * quoting routines found in the quote.c file.
 239  *
 240  * Help to copy the thing properly quoted for the shell safety.  any single
 241  * quote is replaced with '\'', any exclamation point is replaced with '\!',
 242  * and the whole thing is enclosed in a
 243  *
 244  * E.g.
 245  *  original     sq_quote     result
 246  *  name     ==> name      ==> 'name'
 247  *  a b      ==> a b       ==> 'a b'
 248  *  a'b      ==> a'\''b    ==> 'a'\''b'
 249  *  a!b      ==> a'\!'b    ==> 'a'\!'b'
 250  */
 251
 252 static size_t
 253 sq_quote(char buf[SIZEOF_STR], size_t bufsize, const char *src)
 254 {
 255         char c;
 256
 257 #define BUFPUT(x) do { if (bufsize < SIZEOF_STR) buf[bufsize++] = (x); } while (0)
 258
 259         BUFPUT('\'');
 260         while ((c = *src++)) {
 261                 if (c == '\'' || c == '!') {
 262                         BUFPUT('\'');
 263                         BUFPUT('\\');
 264                         BUFPUT(c);
 265                         BUFPUT('\'');
 266                 } else {
 267                         BUFPUT(c);
 268                 }
 269         }
 270         BUFPUT('\'');
 271
 272         if (bufsize < SIZEOF_STR)
 273                 buf[bufsize] = 0;
 274
 275         return bufsize;
 276 }
 277
 278
 279 /*
 280  * User requests
 281  */
 282
 283 #define REQ_INFO \
 284         /* XXX: Keep the view request first and in sync with views[]. */ \
 285         REQ_GROUP("View switching") \
 286         REQ_(VIEW_MAIN,         "Show main view"), \
 287         REQ_(VIEW_DIFF,         "Show diff view"), \
 288         REQ_(VIEW_LOG,          "Show log view"), \
 289         REQ_(VIEW_TREE,         "Show tree view"), \
 290         REQ_(VIEW_BLOB,         "Show blob view"), \
 291         REQ_(VIEW_HELP,         "Show help page"), \
 292         REQ_(VIEW_PAGER,        "Show pager view"), \
 293         \
 294         REQ_GROUP("View manipulation") \
 295         REQ_(ENTER,             "Enter current line and scroll"), \
 296         REQ_(NEXT,              "Move to next"), \
 297         REQ_(PREVIOUS,          "Move to previous"), \
 298         REQ_(VIEW_NEXT,         "Move focus to next view"), \
 299         REQ_(VIEW_CLOSE,        "Close the current view"), \
 300         REQ_(QUIT,              "Close all views and quit"), \
 301         \
 302         REQ_GROUP("Cursor navigation") \
 303         REQ_(MOVE_UP,           "Move cursor one line up"), \
 304         REQ_(MOVE_DOWN,         "Move cursor one line down"), \
 305         REQ_(MOVE_PAGE_DOWN,    "Move cursor one page down"), \
 306         REQ_(MOVE_PAGE_UP,      "Move cursor one page up"), \
 307         REQ_(MOVE_FIRST_LINE,   "Move cursor to first line"), \
 308         REQ_(MOVE_LAST_LINE,    "Move cursor to last line"), \
 309         \
 310         REQ_GROUP("Scrolling") \
 311         REQ_(SCROLL_LINE_UP,    "Scroll one line up"), \
 312         REQ_(SCROLL_LINE_DOWN,  "Scroll one line down"), \
 313         REQ_(SCROLL_PAGE_UP,    "Scroll one page up"), \
 314         REQ_(SCROLL_PAGE_DOWN,  "Scroll one page down"), \
 315         \
 316         REQ_GROUP("Searching") \
 317         REQ_(SEARCH,            "Search the view"), \
 318         REQ_(SEARCH_BACK,       "Search backwards in the view"), \
 319         REQ_(FIND_NEXT,         "Find next search match"), \
 320         REQ_(FIND_PREV,         "Find previous search match"), \
 321         \
 322         REQ_GROUP("Misc") \
 323         REQ_(NONE,              "Do nothing"), \
 324         REQ_(PROMPT,            "Bring up the prompt"), \
 325         REQ_(SCREEN_REDRAW,     "Redraw the screen"), \
 326         REQ_(SCREEN_RESIZE,     "Resize the screen"), \
 327         REQ_(SHOW_VERSION,      "Show version information"), \
 328         REQ_(STOP_LOADING,      "Stop all loading views"), \
 329         REQ_(TOGGLE_LINENO,     "Toggle line numbers"), \
 330         REQ_(TOGGLE_REV_GRAPH,  "Toggle revision graph visualization")
 331
 332
 333 /* User action requests. */
 334 enum request {
 335 #define REQ_GROUP(help)
 336 #define REQ_(req, help) REQ_##req
 337
 338         /* Offset all requests to avoid conflicts with ncurses getch values. */
 339         REQ_OFFSET = KEY_MAX + 1,
 340         REQ_INFO,
 341         REQ_UNKNOWN,
 342
 343 #undef  REQ_GROUP
 344 #undef  REQ_
 345 };
 346
 347 struct request_info {
 348         enum request request;
 349         char *name;
 350         int namelen;
 351         char *help;
 352 };
 353
 354 static struct request_info req_info[] = {
 355 #define REQ_GROUP(help) { 0, NULL, 0, (help) },
 356 #define REQ_(req, help) { REQ_##req, (#req), STRING_SIZE(#req), (help) }
 357         REQ_INFO
 358 #undef  REQ_GROUP
 359 #undef  REQ_
 360 };
 361
 362 static enum request
 363 get_request(const char *name)
 364 {
 365         int namelen = strlen(name);
 366         int i;
 367
 368         for (i = 0; i < ARRAY_SIZE(req_info); i++)
 369                 if (req_info[i].namelen == namelen &&
 370                     !string_enum_compare(req_info[i].name, name, namelen))
 371                         return req_info[i].request;
 372
 373         return REQ_UNKNOWN;
 374 }
 375
 376
 377 /*
 378  * Options
 379  */
 380
 381 static const char usage[] =
 382 VERSION " (" __DATE__ ")\n"
 383 "\n"
 384 "Usage: tig [options]\n"
 385 "   or: tig [options] [--] [git log options]\n"
 386 "   or: tig [options] log  [git log options]\n"
 387 "   or: tig [options] diff [git diff options]\n"
 388 "   or: tig [options] show [git show options]\n"
 389 "   or: tig [options] <    [git command output]\n"
 390 "\n"
 391 "Options:\n"
 392 "  -l                          Start up in log view\n"
 393 "  -d                          Start up in diff view\n"
 394 "  -n[I], --line-number[=I]    Show line numbers with given interval\n"
 395 "  -b[N], --tab-size[=N]       Set number of spaces for tab expansion\n"
 396 "  --                          Mark end of tig options\n"
 397 "  -v, --version               Show version and exit\n"
 398 "  -h, --help                  Show help message and exit\n";
 399
 400 /* Option and state variables. */
 401 static bool opt_line_number             = FALSE;
 402 static bool opt_rev_graph               = FALSE;
 403 static int opt_num_interval             = NUMBER_INTERVAL;
 404 static int opt_tab_size                 = TABSIZE;
 405 static enum request opt_request         = REQ_VIEW_MAIN;
 406 static char opt_cmd[SIZEOF_STR]         = "";
 407 static char opt_path[SIZEOF_STR]        = "";
 408 static FILE *opt_pipe                   = NULL;
 409 static char opt_encoding[20]            = "UTF-8";
 410 static bool opt_utf8                    = TRUE;
 411 static char opt_codeset[20]             = "UTF-8";
 412 static iconv_t opt_iconv                = ICONV_NONE;
 413 static char opt_search[SIZEOF_STR]      = "";
 414
 415 enum option_type {
 416         OPT_NONE,
 417         OPT_INT,
 418 };
 419
 420 static bool
 421 check_option(char *opt, char short_name, char *name, enum option_type type, ...)
 422 {
 423         va_list args;
 424         char *value = "";
 425         int *number;
 426
 427         if (opt[0] != '-')
 428                 return FALSE;
 429
 430         if (opt[1] == '-') {
 431                 int namelen = strlen(name);
 432
 433                 opt += 2;
 434
 435                 if (strncmp(opt, name, namelen))
 436                         return FALSE;
 437
 438                 if (opt[namelen] == '=')
 439                         value = opt + namelen + 1;
 440
 441         } else {
 442                 if (!short_name || opt[1] != short_name)
 443                         return FALSE;
 444                 value = opt + 2;
 445         }
 446
 447         va_start(args, type);
 448         if (type == OPT_INT) {
 449                 number = va_arg(args, int *);
 450                 if (isdigit(*value))
 451                         *number = atoi(value);
 452         }
 453         va_end(args);
 454
 455         return TRUE;
 456 }
 457
 458 /* Returns the index of log or diff command or -1 to exit. */
 459 static bool
 460 parse_options(int argc, char *argv[])
 461 {
 462         int i;
 463
 464         for (i = 1; i < argc; i++) {
 465                 char *opt = argv[i];
 466
 467                 if (!strcmp(opt, "log") ||
 468                     !strcmp(opt, "diff") ||
 469                     !strcmp(opt, "show")) {
 470                         opt_request = opt[0] == 'l'
 471                                     ? REQ_VIEW_LOG : REQ_VIEW_DIFF;
 472                         break;
 473                 }
 474
 475                 if (opt[0] && opt[0] != '-')
 476                         break;
 477
 478                 if (!strcmp(opt, "-l")) {
 479                         opt_request = REQ_VIEW_LOG;
 480                         continue;
 481                 }
 482
 483                 if (!strcmp(opt, "-d")) {
 484                         opt_request = REQ_VIEW_DIFF;
 485                         continue;
 486                 }
 487
 488                 if (check_option(opt, 'n', "line-number", OPT_INT, &opt_num_interval)) {
 489                         opt_line_number = TRUE;
 490                         continue;
 491                 }
 492
 493                 if (check_option(opt, 'b', "tab-size", OPT_INT, &opt_tab_size)) {
 494                         opt_tab_size = MIN(opt_tab_size, TABSIZE);
 495                         continue;
 496                 }
 497
 498                 if (check_option(opt, 'v', "version", OPT_NONE)) {
 499                         printf("tig version %s\n", VERSION);
 500                         return FALSE;
 501                 }
 502
 503                 if (check_option(opt, 'h', "help", OPT_NONE)) {
 504                         printf(usage);
 505                         return FALSE;
 506                 }
 507
 508                 if (!strcmp(opt, "--")) {
 509                         i++;
 510                         break;
 511                 }
 512
 513                 die("unknown option '%s'\n\n%s", opt, usage);
 514         }
 515
 516         if (!isatty(STDIN_FILENO)) {
 517                 opt_request = REQ_VIEW_PAGER;
 518                 opt_pipe = stdin;
 519
 520         } else if (i < argc) {
 521                 size_t buf_size;
 522
 523                 if (opt_request == REQ_VIEW_MAIN)
 524                         /* XXX: This is vulnerable to the user overriding
 525                          * options required for the main view parser. */
 526                         string_copy(opt_cmd, "git log --pretty=raw");
 527                 else
 528                         string_copy(opt_cmd, "git");
 529                 buf_size = strlen(opt_cmd);
 530
 531                 while (buf_size < sizeof(opt_cmd) && i < argc) {
 532                         opt_cmd[buf_size++] = ' ';
 533                         buf_size = sq_quote(opt_cmd, buf_size, argv[i++]);
 534                 }
 535
 536                 if (buf_size >= sizeof(opt_cmd))
 537                         die("command too long");
 538
 539                 opt_cmd[buf_size] = 0;
 540         }
 541
 542         if (*opt_encoding && strcasecmp(opt_encoding, "UTF-8"))
 543                 opt_utf8 = FALSE;
 544
 545         return TRUE;
 546 }
 547
 548
 549 /*
 550  * Line-oriented content detection.
 551  */
 552
 553 #define LINE_INFO \
 554 LINE(DIFF_HEADER,  "diff --git ",       COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 555 LINE(DIFF_CHUNK,   "@@",                COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
 556 LINE(DIFF_ADD,     "+",                 COLOR_GREEN,    COLOR_DEFAULT,  0), \
 557 LINE(DIFF_DEL,     "-",                 COLOR_RED,      COLOR_DEFAULT,  0), \
 558 LINE(DIFF_INDEX,        "index ",         COLOR_BLUE,   COLOR_DEFAULT,  0), \
 559 LINE(DIFF_OLDMODE,      "old file mode ", COLOR_YELLOW, COLOR_DEFAULT,  0), \
 560 LINE(DIFF_NEWMODE,      "new file mode ", COLOR_YELLOW, COLOR_DEFAULT,  0), \
 561 LINE(DIFF_COPY_FROM,    "copy from",      COLOR_YELLOW, COLOR_DEFAULT,  0), \
 562 LINE(DIFF_COPY_TO,      "copy to",        COLOR_YELLOW, COLOR_DEFAULT,  0), \
 563 LINE(DIFF_RENAME_FROM,  "rename from",    COLOR_YELLOW, COLOR_DEFAULT,  0), \
 564 LINE(DIFF_RENAME_TO,    "rename to",      COLOR_YELLOW, COLOR_DEFAULT,  0), \
 565 LINE(DIFF_SIMILARITY,   "similarity ",    COLOR_YELLOW, COLOR_DEFAULT,  0), \
 566 LINE(DIFF_DISSIMILARITY,"dissimilarity ", COLOR_YELLOW, COLOR_DEFAULT,  0), \
 567 LINE(DIFF_TREE,         "diff-tree ",     COLOR_BLUE,   COLOR_DEFAULT,  0), \
 568 LINE(PP_AUTHOR,    "Author: ",          COLOR_CYAN,     COLOR_DEFAULT,  0), \
 569 LINE(PP_COMMIT,    "Commit: ",          COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
 570 LINE(PP_MERGE,     "Merge: ",           COLOR_BLUE,     COLOR_DEFAULT,  0), \
 571 LINE(PP_DATE,      "Date:   ",          COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 572 LINE(PP_ADATE,     "AuthorDate: ",      COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 573 LINE(PP_CDATE,     "CommitDate: ",      COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 574 LINE(PP_REFS,      "Refs: ",            COLOR_RED,      COLOR_DEFAULT,  0), \
 575 LINE(COMMIT,       "commit ",           COLOR_GREEN,    COLOR_DEFAULT,  0), \
 576 LINE(PARENT,       "parent ",           COLOR_BLUE,     COLOR_DEFAULT,  0), \
 577 LINE(TREE,         "tree ",             COLOR_BLUE,     COLOR_DEFAULT,  0), \
 578 LINE(AUTHOR,       "author ",           COLOR_CYAN,     COLOR_DEFAULT,  0), \
 579 LINE(COMMITTER,    "committer ",        COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
 580 LINE(SIGNOFF,      "    Signed-off-by", COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 581 LINE(ACKED,        "    Acked-by",      COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 582 LINE(DEFAULT,      "",                  COLOR_DEFAULT,  COLOR_DEFAULT,  A_NORMAL), \
 583 LINE(CURSOR,       "",                  COLOR_WHITE,    COLOR_GREEN,    A_BOLD), \
 584 LINE(STATUS,       "",                  COLOR_GREEN,    COLOR_DEFAULT,  0), \
 585 LINE(TITLE_BLUR,   "",                  COLOR_WHITE,    COLOR_BLUE,     0), \
 586 LINE(TITLE_FOCUS,  "",                  COLOR_WHITE,    COLOR_BLUE,     A_BOLD), \
 587 LINE(MAIN_DATE,    "",                  COLOR_BLUE,     COLOR_DEFAULT,  0), \
 588 LINE(MAIN_AUTHOR,  "",                  COLOR_GREEN,    COLOR_DEFAULT,  0), \
 589 LINE(MAIN_COMMIT,  "",                  COLOR_DEFAULT,  COLOR_DEFAULT,  0), \
 590 LINE(MAIN_DELIM,   "",                  COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
 591 LINE(MAIN_TAG,     "",                  COLOR_MAGENTA,  COLOR_DEFAULT,  A_BOLD), \
 592 LINE(MAIN_REMOTE,  "",                  COLOR_YELLOW,   COLOR_DEFAULT,  A_BOLD), \
 593 LINE(MAIN_REF,     "",                  COLOR_CYAN,     COLOR_DEFAULT,  A_BOLD), \
 594 LINE(TREE_DIR,     "",                  COLOR_DEFAULT,  COLOR_DEFAULT,  A_NORMAL), \
 595 LINE(TREE_FILE,    "",                  COLOR_DEFAULT,  COLOR_DEFAULT,  A_NORMAL)
 596
 597 enum line_type {
 598 #define LINE(type, line, fg, bg, attr) \
 599         LINE_##type
 600         LINE_INFO
 601 #undef  LINE
 602 };
 603
 604 struct line_info {
 605         const char *name;       /* Option name. */
 606         int namelen;            /* Size of option name. */
 607         const char *line;       /* The start of line to match. */
 608         int linelen;            /* Size of string to match. */
 609         int fg, bg, attr;       /* Color and text attributes for the lines. */
 610 };
 611
 612 static struct line_info line_info[] = {
 613 #define LINE(type, line, fg, bg, attr) \
 614         { #type, STRING_SIZE(#type), (line), STRING_SIZE(line), (fg), (bg), (attr) }
 615         LINE_INFO
 616 #undef  LINE
 617 };
 618
 619 static enum line_type
 620 get_line_type(char *line)
 621 {
 622         int linelen = strlen(line);
 623         enum line_type type;
 624
 625         for (type = 0; type < ARRAY_SIZE(line_info); type++)
 626                 /* Case insensitive search matches Signed-off-by lines better. */
 627                 if (linelen >= line_info[type].linelen &&
 628                     !strncasecmp(line_info[type].line, line, line_info[type].linelen))
 629                         return type;
 630
 631         return LINE_DEFAULT;
 632 }
 633
 634 static inline int
 635 get_line_attr(enum line_type type)
 636 {
 637         assert(type < ARRAY_SIZE(line_info));
 638         return COLOR_PAIR(type) | line_info[type].attr;
 639 }
 640
 641 static struct line_info *
 642 get_line_info(char *name, int namelen)
 643 {
 644         enum line_type type;
 645
 646         for (type = 0; type < ARRAY_SIZE(line_info); type++)
 647                 if (namelen == line_info[type].namelen &&
 648                     !string_enum_compare(line_info[type].name, name, namelen))
 649                         return &line_info[type];
 650
 651         return NULL;
 652 }
 653
 654 static void
 655 init_colors(void)
 656 {
 657         int default_bg = COLOR_BLACK;
 658         int default_fg = COLOR_WHITE;
 659         enum line_type type;
 660
 661         start_color();
 662
 663         if (use_default_colors() != ERR) {
 664                 default_bg = -1;
 665                 default_fg = -1;
 666         }
 667
 668         for (type = 0; type < ARRAY_SIZE(line_info); type++) {
 669                 struct line_info *info = &line_info[type];
 670                 int bg = info->bg == COLOR_DEFAULT ? default_bg : info->bg;
 671                 int fg = info->fg == COLOR_DEFAULT ? default_fg : info->fg;
 672
 673                 init_pair(type, fg, bg);
 674         }
 675 }
 676
 677 struct line {
 678         enum line_type type;
 679
 680         /* State flags */
 681         unsigned int selected:1;
 682
 683         void *data;             /* User data */
 684 };
 685
 686
 687 /*
 688  * Keys
 689  */
 690
 691 struct keybinding {
 692         int alias;
 693         enum request request;
 694         struct keybinding *next;
 695 };
 696
 697 static struct keybinding default_keybindings[] = {
 698         /* View switching */
 699         { 'm',          REQ_VIEW_MAIN },
 700         { 'd',          REQ_VIEW_DIFF },
 701         { 'l',          REQ_VIEW_LOG },
 702         { 't',          REQ_VIEW_TREE },
 703         { 'f',          REQ_VIEW_BLOB },
 704         { 'p',          REQ_VIEW_PAGER },
 705         { 'h',          REQ_VIEW_HELP },
 706
 707         /* View manipulation */
 708         { 'q',          REQ_VIEW_CLOSE },
 709         { KEY_TAB,      REQ_VIEW_NEXT },
 710         { KEY_RETURN,   REQ_ENTER },
 711         { KEY_UP,       REQ_PREVIOUS },
 712         { KEY_DOWN,     REQ_NEXT },
 713
 714         /* Cursor navigation */
 715         { 'k',          REQ_MOVE_UP },
 716         { 'j',          REQ_MOVE_DOWN },
 717         { KEY_HOME,     REQ_MOVE_FIRST_LINE },
 718         { KEY_END,      REQ_MOVE_LAST_LINE },
 719         { KEY_NPAGE,    REQ_MOVE_PAGE_DOWN },
 720         { ' ',          REQ_MOVE_PAGE_DOWN },
 721         { KEY_PPAGE,    REQ_MOVE_PAGE_UP },
 722         { 'b',          REQ_MOVE_PAGE_UP },
 723         { '-',          REQ_MOVE_PAGE_UP },
 724
 725         /* Scrolling */
 726         { KEY_IC,       REQ_SCROLL_LINE_UP },
 727         { KEY_DC,       REQ_SCROLL_LINE_DOWN },
 728         { 'w',          REQ_SCROLL_PAGE_UP },
 729         { 's',          REQ_SCROLL_PAGE_DOWN },
 730
 731         /* Searching */
 732         { '/',          REQ_SEARCH },
 733         { '?',          REQ_SEARCH_BACK },
 734         { 'n',          REQ_FIND_NEXT },
 735         { 'N',          REQ_FIND_PREV },
 736
 737         /* Misc */
 738         { 'Q',          REQ_QUIT },
 739         { 'z',          REQ_STOP_LOADING },
 740         { 'v',          REQ_SHOW_VERSION },
 741         { 'r',          REQ_SCREEN_REDRAW },
 742         { '.',          REQ_TOGGLE_LINENO },
 743         { 'g',          REQ_TOGGLE_REV_GRAPH },
 744         { ':',          REQ_PROMPT },
 745
 746         /* Using the ncurses SIGWINCH handler. */
 747         { KEY_RESIZE,   REQ_SCREEN_RESIZE },
 748 };
 749
 750 #define KEYMAP_INFO \
 751         KEYMAP_(GENERIC), \
 752         KEYMAP_(MAIN), \
 753         KEYMAP_(DIFF), \
 754         KEYMAP_(LOG), \
 755         KEYMAP_(TREE), \
 756         KEYMAP_(BLOB), \
 757         KEYMAP_(PAGER), \
 758         KEYMAP_(HELP) \
 759
 760 enum keymap {
 761 #define KEYMAP_(name) KEYMAP_##name
 762         KEYMAP_INFO
 763 #undef  KEYMAP_
 764 };
 765
 766 static struct int_map keymap_table[] = {
 767 #define KEYMAP_(name) { #name, STRING_SIZE(#name), KEYMAP_##name }
 768         KEYMAP_INFO
 769 #undef  KEYMAP_
 770 };
 771
 772 #define set_keymap(map, name) \
 773         set_from_int_map(keymap_table, ARRAY_SIZE(keymap_table), map, name, strlen(name))
 774
 775 static struct keybinding *keybindings[ARRAY_SIZE(keymap_table)];
 776
 777 static void
 778 add_keybinding(enum keymap keymap, enum request request, int key)
 779 {
 780         struct keybinding *keybinding;
 781
 782         keybinding = calloc(1, sizeof(*keybinding));
 783         if (!keybinding)
 784                 die("Failed to allocate keybinding");
 785
 786         keybinding->alias = key;
 787         keybinding->request = request;
 788         keybinding->next = keybindings[keymap];
 789         keybindings[keymap] = keybinding;
 790 }
 791
 792 /* Looks for a key binding first in the given map, then in the generic map, and
 793  * lastly in the default keybindings. */
 794 static enum request
 795 get_keybinding(enum keymap keymap, int key)
 796 {
 797         struct keybinding *kbd;
 798         int i;
 799
 800         for (kbd = keybindings[keymap]; kbd; kbd = kbd->next)
 801                 if (kbd->alias == key)
 802                         return kbd->request;
 803
 804         for (kbd = keybindings[KEYMAP_GENERIC]; kbd; kbd = kbd->next)
 805                 if (kbd->alias == key)
 806                         return kbd->request;
 807
 808         for (i = 0; i < ARRAY_SIZE(default_keybindings); i++)
 809                 if (default_keybindings[i].alias == key)
 810                         return default_keybindings[i].request;
 811
 812         return (enum request) key;
 813 }
 814
 815
 816 struct key {
 817         char *name;
 818         int value;
 819 };
 820
 821 static struct key key_table[] = {
 822         { "Enter",      KEY_RETURN },
 823         { "Space",      ' ' },
 824         { "Backspace",  KEY_BACKSPACE },
 825         { "Tab",        KEY_TAB },
 826         { "Escape",     KEY_ESC },
 827         { "Left",       KEY_LEFT },
 828         { "Right",      KEY_RIGHT },
 829         { "Up",         KEY_UP },
 830         { "Down",       KEY_DOWN },
 831         { "Insert",     KEY_IC },
 832         { "Delete",     KEY_DC },
 833         { "Hash",       '#' },
 834         { "Home",       KEY_HOME },
 835         { "End",        KEY_END },
 836         { "PageUp",     KEY_PPAGE },
 837         { "PageDown",   KEY_NPAGE },
 838         { "F1",         KEY_F(1) },
 839         { "F2",         KEY_F(2) },
 840         { "F3",         KEY_F(3) },
 841         { "F4",         KEY_F(4) },
 842         { "F5",         KEY_F(5) },
 843         { "F6",         KEY_F(6) },
 844         { "F7",         KEY_F(7) },
 845         { "F8",         KEY_F(8) },
 846         { "F9",         KEY_F(9) },
 847         { "F10",        KEY_F(10) },
 848         { "F11",        KEY_F(11) },
 849         { "F12",        KEY_F(12) },
 850 };
 851
 852 static int
 853 get_key_value(const char *name)
 854 {
 855         int i;
 856
 857         for (i = 0; i < ARRAY_SIZE(key_table); i++)
 858                 if (!strcasecmp(key_table[i].name, name))
 859                         return key_table[i].value;
 860
 861         if (strlen(name) == 1 && isprint(*name))
 862                 return (int) *name;
 863
 864         return ERR;
 865 }
 866
 867 static char *
 868 get_key(enum request request)
 869 {
 870         static char buf[BUFSIZ];
 871         static char key_char[] = "'X'";
 872         size_t pos = 0;
 873         char *sep = "";
 874         int i;
 875
 876         buf[pos] = 0;
 877
 878         for (i = 0; i < ARRAY_SIZE(default_keybindings); i++) {
 879                 struct keybinding *keybinding = &default_keybindings[i];
 880                 char *seq = NULL;
 881                 int key;
 882
 883                 if (keybinding->request != request)
 884                         continue;
 885
 886                 for (key = 0; key < ARRAY_SIZE(key_table); key++)
 887                         if (key_table[key].value == keybinding->alias)
 888                                 seq = key_table[key].name;
 889
 890                 if (seq == NULL &&
 891                     keybinding->alias < 127 &&
 892                     isprint(keybinding->alias)) {
 893                         key_char[1] = (char) keybinding->alias;
 894                         seq = key_char;
 895                 }
 896
 897                 if (!seq)
 898                         seq = "'?'";
 899
 900                 if (!string_format_from(buf, &pos, "%s%s", sep, seq))
 901                         return "Too many keybindings!";
 902                 sep = ", ";
 903         }
 904
 905         return buf;
 906 }
 907
 908
 909 /*
 910  * User config file handling.
 911  */
 912
 913 static struct int_map color_map[] = {
 914 #define COLOR_MAP(name) { #name, STRING_SIZE(#name), COLOR_##name }
 915         COLOR_MAP(DEFAULT),
 916         COLOR_MAP(BLACK),
 917         COLOR_MAP(BLUE),
 918         COLOR_MAP(CYAN),
 919         COLOR_MAP(GREEN),
 920         COLOR_MAP(MAGENTA),
 921         COLOR_MAP(RED),
 922         COLOR_MAP(WHITE),
 923         COLOR_MAP(YELLOW),
 924 };
 925
 926 #define set_color(color, name) \
 927         set_from_int_map(color_map, ARRAY_SIZE(color_map), color, name, strlen(name))
 928
 929 static struct int_map attr_map[] = {
 930 #define ATTR_MAP(name) { #name, STRING_SIZE(#name), A_##name }
 931         ATTR_MAP(NORMAL),
 932         ATTR_MAP(BLINK),
 933         ATTR_MAP(BOLD),
 934         ATTR_MAP(DIM),
 935         ATTR_MAP(REVERSE),
 936         ATTR_MAP(STANDOUT),
 937         ATTR_MAP(UNDERLINE),
 938 };
 939
 940 #define set_attribute(attr, name) \
 941         set_from_int_map(attr_map, ARRAY_SIZE(attr_map), attr, name, strlen(name))
 942
 943 static int   config_lineno;
 944 static bool  config_errors;
 945 static char *config_msg;
 946
 947 /* Wants: object fgcolor bgcolor [attr] */
 948 static int
 949 option_color_command(int argc, char *argv[])
 950 {
 951         struct line_info *info;
 952
 953         if (argc != 3 && argc != 4) {
 954                 config_msg = "Wrong number of arguments given to color command";
 955                 return ERR;
 956         }
 957
 958         info = get_line_info(argv[0], strlen(argv[0]));
 959         if (!info) {
 960                 config_msg = "Unknown color name";
 961                 return ERR;
 962         }
 963
 964         if (set_color(&info->fg, argv[1]) == ERR ||
 965             set_color(&info->bg, argv[2]) == ERR) {
 966                 config_msg = "Unknown color";
 967                 return ERR;
 968         }
 969
 970         if (argc == 4 && set_attribute(&info->attr, argv[3]) == ERR) {
 971                 config_msg = "Unknown attribute";
 972                 return ERR;
 973         }
 974
 975         return OK;
 976 }
 977
 978 /* Wants: name = value */
 979 static int
 980 option_set_command(int argc, char *argv[])
 981 {
 982         if (argc != 3) {
 983                 config_msg = "Wrong number of arguments given to set command";
 984                 return ERR;
 985         }
 986
 987         if (strcmp(argv[1], "=")) {
 988                 config_msg = "No value assigned";
 989                 return ERR;
 990         }
 991
 992         if (!strcmp(argv[0], "show-rev-graph")) {
 993                 opt_rev_graph = (!strcmp(argv[2], "1") ||
 994                                  !strcmp(argv[2], "true") ||
 995                                  !strcmp(argv[2], "yes"));
 996                 return OK;
 997         }
 998
 999         if (!strcmp(argv[0], "line-number-interval")) {
1000                 opt_num_interval = atoi(argv[2]);
1001                 return OK;
1002         }
1003
1004         if (!strcmp(argv[0], "tab-size")) {
1005                 opt_tab_size = atoi(argv[2]);
1006                 return OK;
1007         }
1008
1009         if (!strcmp(argv[0], "commit-encoding")) {
1010                 char *arg = argv[2];
1011                 int delimiter = *arg;
1012                 int i;
1013
1014                 switch (delimiter) {
1015                 case '"':
1016                 case '\'':
1017                         for (arg++, i = 0; arg[i]; i++)
1018                                 if (arg[i] == delimiter) {
1019                                         arg[i] = 0;
1020                                         break;
1021                                 }
1022                 default:
1023                         string_copy(opt_encoding, arg);
1024                         return OK;
1025                 }
1026         }
1027
1028         config_msg = "Unknown variable name";
1029         return ERR;
1030 }
1031
1032 /* Wants: mode request key */
1033 static int
1034 option_bind_command(int argc, char *argv[])
1035 {
1036         enum request request;
1037         int keymap;
1038         int key;
1039
1040         if (argc != 3) {
1041                 config_msg = "Wrong number of arguments given to bind command";
1042                 return ERR;
1043         }
1044
1045         if (set_keymap(&keymap, argv[0]) == ERR) {
1046                 config_msg = "Unknown key map";
1047                 return ERR;
1048         }
1049
1050         key = get_key_value(argv[1]);
1051         if (key == ERR) {
1052                 config_msg = "Unknown key";
1053                 return ERR;
1054         }
1055
1056         request = get_request(argv[2]);
1057         if (request == REQ_UNKNOWN) {
1058                 config_msg = "Unknown request name";
1059                 return ERR;
1060         }
1061
1062         add_keybinding(keymap, request, key);
1063
1064         return OK;
1065 }
1066
1067 static int
1068 set_option(char *opt, char *value)
1069 {
1070         char *argv[16];
1071         int valuelen;
1072         int argc = 0;
1073
1074         /* Tokenize */
1075         while (argc < ARRAY_SIZE(argv) && (valuelen = strcspn(value, " \t"))) {
1076                 argv[argc++] = value;
1077
1078                 value += valuelen;
1079                 if (!*value)
1080                         break;
1081
1082                 *value++ = 0;
1083                 while (isspace(*value))
1084                         value++;
1085         }
1086
1087         if (!strcmp(opt, "color"))
1088                 return option_color_command(argc, argv);
1089
1090         if (!strcmp(opt, "set"))
1091                 return option_set_command(argc, argv);
1092
1093         if (!strcmp(opt, "bind"))
1094                 return option_bind_command(argc, argv);
1095
1096         config_msg = "Unknown option command";
1097         return ERR;
1098 }
1099
1100 static int
1101 read_option(char *opt, int optlen, char *value, int valuelen)
1102 {
1103         int status = OK;
1104
1105         config_lineno++;
1106         config_msg = "Internal error";
1107
1108         /* Check for comment markers, since read_properties() will
1109          * only ensure opt and value are split at first " \t". */
1110         optlen = strcspn(opt, "#");
1111         if (optlen == 0)
1112                 return OK;
1113
1114         if (opt[optlen] != 0) {
1115                 config_msg = "No option value";
1116                 status = ERR;
1117
1118         }  else {
1119                 /* Look for comment endings in the value. */
1120                 int len = strcspn(value, "#");
1121
1122                 if (len < valuelen) {
1123                         valuelen = len;
1124                         value[valuelen] = 0;
1125                 }
1126
1127                 status = set_option(opt, value);
1128         }
1129
1130         if (status == ERR) {
1131                 fprintf(stderr, "Error on line %d, near '%.*s': %s\n",
1132                         config_lineno, optlen, opt, config_msg);
1133                 config_errors = TRUE;
1134         }
1135
1136         /* Always keep going if errors are encountered. */
1137         return OK;
1138 }
1139
1140 static int
1141 load_options(void)
1142 {
1143         char *home = getenv("HOME");
1144         char buf[SIZEOF_STR];
1145         FILE *file;
1146
1147         config_lineno = 0;
1148         config_errors = FALSE;
1149
1150         if (!home || !string_format(buf, "%s/.tigrc", home))
1151                 return ERR;
1152
1153         /* It's ok that the file doesn't exist. */
1154         file = fopen(buf, "r");
1155         if (!file)
1156                 return OK;
1157
1158         if (read_properties(file, " \t", read_option) == ERR ||
1159             config_errors == TRUE)
1160                 fprintf(stderr, "Errors while loading %s.\n", buf);
1161
1162         return OK;
1163 }
1164
1165
1166 /*
1167  * The viewer
1168  */
1169
1170 struct view;
1171 struct view_ops;
1172
1173 /* The display array of active views and the index of the current view. */
1174 static struct view *display[2];
1175 static unsigned int current_view;
1176
1177 /* Reading from the prompt? */
1178 static bool input_mode = FALSE;
1179
1180 #define foreach_displayed_view(view, i) \
1181         for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
1182
1183 #define displayed_views()       (display[1] != NULL ? 2 : 1)
1184
1185 /* Current head and commit ID */
1186 static char ref_blob[SIZEOF_REF]        = "";
1187 static char ref_commit[SIZEOF_REF]      = "HEAD";
1188 static char ref_head[SIZEOF_REF]        = "HEAD";
1189
1190 struct view {
1191         const char *name;       /* View name */
1192         const char *cmd_fmt;    /* Default command line format */
1193         const char *cmd_env;    /* Command line set via environment */
1194         const char *id;         /* Points to either of ref_{head,commit,blob} */
1195
1196         struct view_ops *ops;   /* View operations */
1197
1198         enum keymap keymap;     /* What keymap does this view have */
1199
1200         char cmd[SIZEOF_STR];   /* Command buffer */
1201         char ref[SIZEOF_REF];   /* Hovered commit reference */
1202         char vid[SIZEOF_REF];   /* View ID. Set to id member when updating. */
1203
1204         int height, width;      /* The width and height of the main window */
1205         WINDOW *win;            /* The main window */
1206         WINDOW *title;          /* The title window living below the main window */
1207
1208         /* Navigation */
1209         unsigned long offset;   /* Offset of the window top */
1210         unsigned long lineno;   /* Current line number */
1211
1212         /* Searching */
1213         char grep[SIZEOF_STR];  /* Search string */
1214         regex_t *regex;         /* Pre-compiled regex */
1215
1216         /* If non-NULL, points to the view that opened this view. If this view
1217          * is closed tig will switch back to the parent view. */
1218         struct view *parent;
1219
1220         /* Buffering */
1221         unsigned long lines;    /* Total number of lines */
1222         struct line *line;      /* Line index */
1223         unsigned long line_size;/* Total number of allocated lines */
1224         unsigned int digits;    /* Number of digits in the lines member. */
1225
1226         /* Loading */
1227         FILE *pipe;
1228         time_t start_time;
1229 };
1230
1231 struct view_ops {
1232         /* What type of content being displayed. Used in the title bar. */
1233         const char *type;
1234         /* Draw one line; @lineno must be < view->height. */
1235         bool (*draw)(struct view *view, struct line *line, unsigned int lineno, bool selected);
1236         /* Read one line; updates view->line. */
1237         bool (*read)(struct view *view, char *data);
1238         /* Depending on view, change display based on current line. */
1239         bool (*enter)(struct view *view, struct line *line);
1240         /* Search for regex in a line. */
1241         bool (*grep)(struct view *view, struct line *line);
1242         /* Select line */
1243         void (*select)(struct view *view, struct line *line);
1244 };
1245
1246 static struct view_ops pager_ops;
1247 static struct view_ops main_ops;
1248 static struct view_ops tree_ops;
1249 static struct view_ops blob_ops;
1250
1251 #define VIEW_STR(name, cmd, env, ref, ops, map) \
1252         { name, cmd, #env, ref, ops, map}
1253
1254 #define VIEW_(id, name, ops, ref) \
1255         VIEW_STR(name, TIG_##id##_CMD,  TIG_##id##_CMD, ref, ops, KEYMAP_##id)
1256
1257
1258 static struct view views[] = {
1259         VIEW_(MAIN,  "main",  &main_ops,  ref_head),
1260         VIEW_(DIFF,  "diff",  &pager_ops, ref_commit),
1261         VIEW_(LOG,   "log",   &pager_ops, ref_head),
1262         VIEW_(TREE,  "tree",  &tree_ops,  ref_commit),
1263         VIEW_(BLOB,  "blob",  &blob_ops,  ref_blob),
1264         VIEW_(HELP,  "help",  &pager_ops, ""),
1265         VIEW_(PAGER, "pager", &pager_ops, ""),
1266 };
1267
1268 #define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
1269
1270 #define foreach_view(view, i) \
1271         for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
1272
1273 #define view_is_displayed(view) \
1274         (view == display[0] || view == display[1])
1275
1276 static bool
1277 draw_view_line(struct view *view, unsigned int lineno)
1278 {
1279         struct line *line;
1280         bool selected = (view->offset + lineno == view->lineno);
1281         bool draw_ok;
1282
1283         assert(view_is_displayed(view));
1284
1285         if (view->offset + lineno >= view->lines)
1286                 return FALSE;
1287
1288         line = &view->line[view->offset + lineno];
1289
1290         if (selected) {
1291                 line->selected = TRUE;
1292                 view->ops->select(view, line);
1293         } else if (line->selected) {
1294                 line->selected = FALSE;
1295                 wmove(view->win, lineno, 0);
1296                 wclrtoeol(view->win);
1297         }
1298
1299         scrollok(view->win, FALSE);
1300         draw_ok = view->ops->draw(view, line, lineno, selected);
1301         scrollok(view->win, TRUE);
1302
1303         return draw_ok;
1304 }
1305
1306 static void
1307 redraw_view_from(struct view *view, int lineno)
1308 {
1309         assert(0 <= lineno && lineno < view->height);
1310
1311         for (; lineno < view->height; lineno++) {
1312                 if (!draw_view_line(view, lineno))
1313                         break;
1314         }
1315
1316         redrawwin(view->win);
1317         if (input_mode)
1318                 wnoutrefresh(view->win);
1319         else
1320                 wrefresh(view->win);
1321 }
1322
1323 static void
1324 redraw_view(struct view *view)
1325 {
1326         wclear(view->win);
1327         redraw_view_from(view, 0);
1328 }
1329
1330
1331 static void
1332 update_view_title(struct view *view)
1333 {
1334         char buf[SIZEOF_STR];
1335         char state[SIZEOF_STR];
1336         size_t bufpos = 0, statelen = 0;
1337
1338         assert(view_is_displayed(view));
1339
1340         if (view->lines || view->pipe) {
1341                 unsigned int view_lines = view->offset + view->height;
1342                 unsigned int lines = view->lines
1343                                    ? MIN(view_lines, view->lines) * 100 / view->lines
1344                                    : 0;
1345
1346                 string_format_from(state, &statelen, "- %s %d of %d (%d%%)",
1347                                    view->ops->type,
1348                                    view->lineno + 1,
1349                                    view->lines,
1350                                    lines);
1351
1352                 if (view->pipe) {
1353                         time_t secs = time(NULL) - view->start_time;
1354
1355                         /* Three git seconds are a long time ... */
1356                         if (secs > 2)
1357                                 string_format_from(state, &statelen, " %lds", secs);
1358                 }
1359         }
1360
1361         string_format_from(buf, &bufpos, "[%s]", view->name);
1362         if (*view->ref && bufpos < view->width) {
1363                 size_t refsize = strlen(view->ref);
1364                 size_t minsize = bufpos + 1 + /* abbrev= */ 7 + 1 + statelen;
1365
1366                 if (minsize < view->width)
1367                         refsize = view->width - minsize + 7;
1368                 string_format_from(buf, &bufpos, " %.*s", refsize, view->ref);
1369         }
1370
1371         if (statelen && bufpos < view->width) {
1372                 string_format_from(buf, &bufpos, " %s", state);
1373         }
1374
1375         if (view == display[current_view])
1376                 wbkgdset(view->title, get_line_attr(LINE_TITLE_FOCUS));
1377         else
1378                 wbkgdset(view->title, get_line_attr(LINE_TITLE_BLUR));
1379
1380         mvwaddnstr(view->title, 0, 0, buf, bufpos);
1381         wclrtoeol(view->title);
1382         wmove(view->title, 0, view->width - 1);
1383
1384         if (input_mode)
1385                 wnoutrefresh(view->title);
1386         else
1387                 wrefresh(view->title);
1388 }
1389
1390 static void
1391 resize_display(void)
1392 {
1393         int offset, i;
1394         struct view *base = display[0];
1395         struct view *view = display[1] ? display[1] : display[0];
1396
1397         /* Setup window dimensions */
1398
1399         getmaxyx(stdscr, base->height, base->width);
1400
1401         /* Make room for the status window. */
1402         base->height -= 1;
1403
1404         if (view != base) {
1405                 /* Horizontal split. */
1406                 view->width   = base->width;
1407                 view->height  = SCALE_SPLIT_VIEW(base->height);
1408                 base->height -= view->height;
1409
1410                 /* Make room for the title bar. */
1411                 view->height -= 1;
1412         }
1413
1414         /* Make room for the title bar. */
1415         base->height -= 1;
1416
1417         offset = 0;
1418
1419         foreach_displayed_view (view, i) {
1420                 if (!view->win) {
1421                         view->win = newwin(view->height, 0, offset, 0);
1422                         if (!view->win)
1423                                 die("Failed to create %s view", view->name);
1424
1425                         scrollok(view->win, TRUE);
1426
1427                         view->title = newwin(1, 0, offset + view->height, 0);
1428                         if (!view->title)
1429                                 die("Failed to create title window");
1430
1431                 } else {
1432                         wresize(view->win, view->height, view->width);
1433                         mvwin(view->win,   offset, 0);
1434                         mvwin(view->title, offset + view->height, 0);
1435                 }
1436
1437                 offset += view->height + 1;
1438         }
1439 }
1440
1441 static void
1442 redraw_display(void)
1443 {
1444         struct view *view;
1445         int i;
1446
1447         foreach_displayed_view (view, i) {
1448                 redraw_view(view);
1449                 update_view_title(view);
1450         }
1451 }
1452
1453 static void
1454 update_display_cursor(struct view *view)
1455 {
1456         /* Move the cursor to the right-most column of the cursor line.
1457          *
1458          * XXX: This could turn out to be a bit expensive, but it ensures that
1459          * the cursor does not jump around. */
1460         if (view->lines) {
1461                 wmove(view->win, view->lineno - view->offset, view->width - 1);
1462                 wrefresh(view->win);
1463         }
1464 }
1465
1466 /*
1467  * Navigation
1468  */
1469
1470 /* Scrolling backend */
1471 static void
1472 do_scroll_view(struct view *view, int lines)
1473 {
1474         bool redraw_current_line = FALSE;
1475
1476         /* The rendering expects the new offset. */
1477         view->offset += lines;
1478
1479         assert(0 <= view->offset && view->offset < view->lines);
1480         assert(lines);
1481
1482         /* Move current line into the view. */
1483         if (view->lineno < view->offset) {
1484                 view->lineno = view->offset;
1485                 redraw_current_line = TRUE;
1486         } else if (view->lineno >= view->offset + view->height) {
1487                 view->lineno = view->offset + view->height - 1;
1488                 redraw_current_line = TRUE;
1489         }
1490
1491         assert(view->offset <= view->lineno && view->lineno < view->lines);
1492
1493         /* Redraw the whole screen if scrolling is pointless. */
1494         if (view->height < ABS(lines)) {
1495                 redraw_view(view);
1496
1497         } else {
1498                 int line = lines > 0 ? view->height - lines : 0;
1499                 int end = line + ABS(lines);
1500
1501                 wscrl(view->win, lines);
1502
1503                 for (; line < end; line++) {
1504                         if (!draw_view_line(view, line))
1505                                 break;
1506                 }
1507
1508                 if (redraw_current_line)
1509                         draw_view_line(view, view->lineno - view->offset);
1510         }
1511
1512         redrawwin(view->win);
1513         wrefresh(view->win);
1514         report("");
1515 }
1516
1517 /* Scroll frontend */
1518 static void
1519 scroll_view(struct view *view, enum request request)
1520 {
1521         int lines = 1;
1522
1523         assert(view_is_displayed(view));
1524
1525         switch (request) {
1526         case REQ_SCROLL_PAGE_DOWN:
1527                 lines = view->height;
1528         case REQ_SCROLL_LINE_DOWN:
1529                 if (view->offset + lines > view->lines)
1530                         lines = view->lines - view->offset;
1531
1532                 if (lines == 0 || view->offset + view->height >= view->lines) {
1533                         report("Cannot scroll beyond the last line");
1534                         return;
1535                 }
1536                 break;
1537
1538         case REQ_SCROLL_PAGE_UP:
1539                 lines = view->height;
1540         case REQ_SCROLL_LINE_UP:
1541                 if (lines > view->offset)
1542                         lines = view->offset;
1543
1544                 if (lines == 0) {
1545                         report("Cannot scroll beyond the first line");
1546                         return;
1547                 }
1548
1549                 lines = -lines;
1550                 break;
1551
1552         default:
1553                 die("request %d not handled in switch", request);
1554         }
1555
1556         do_scroll_view(view, lines);
1557 }
1558
1559 /* Cursor moving */
1560 static void
1561 move_view(struct view *view, enum request request)
1562 {
1563         int scroll_steps = 0;
1564         int steps;
1565
1566         switch (request) {
1567         case REQ_MOVE_FIRST_LINE:
1568                 steps = -view->lineno;
1569                 break;
1570
1571         case REQ_MOVE_LAST_LINE:
1572                 steps = view->lines - view->lineno - 1;
1573                 break;
1574
1575         case REQ_MOVE_PAGE_UP:
1576                 steps = view->height > view->lineno
1577                       ? -view->lineno : -view->height;
1578                 break;
1579
1580         case REQ_MOVE_PAGE_DOWN:
1581                 steps = view->lineno + view->height >= view->lines
1582                       ? view->lines - view->lineno - 1 : view->height;
1583                 break;
1584
1585         case REQ_MOVE_UP:
1586                 steps = -1;
1587                 break;
1588
1589         case REQ_MOVE_DOWN:
1590                 steps = 1;
1591                 break;
1592
1593         default:
1594                 die("request %d not handled in switch", request);
1595         }
1596
1597         if (steps <= 0 && view->lineno == 0) {
1598                 report("Cannot move beyond the first line");
1599                 return;
1600
1601         } else if (steps >= 0 && view->lineno + 1 >= view->lines) {
1602                 report("Cannot move beyond the last line");
1603                 return;
1604         }
1605
1606         /* Move the current line */
1607         view->lineno += steps;
1608         assert(0 <= view->lineno && view->lineno < view->lines);
1609
1610         /* Check whether the view needs to be scrolled */
1611         if (view->lineno < view->offset ||
1612             view->lineno >= view->offset + view->height) {
1613                 scroll_steps = steps;
1614                 if (steps < 0 && -steps > view->offset) {
1615                         scroll_steps = -view->offset;
1616
1617                 } else if (steps > 0) {
1618                         if (view->lineno == view->lines - 1 &&
1619                             view->lines > view->height) {
1620                                 scroll_steps = view->lines - view->offset - 1;
1621                                 if (scroll_steps >= view->height)
1622                                         scroll_steps -= view->height - 1;
1623                         }
1624                 }
1625         }
1626
1627         if (!view_is_displayed(view)) {
1628                 view->offset += scroll_steps;
1629                 assert(0 <= view->offset && view->offset < view->lines);
1630                 view->ops->select(view, &view->line[view->lineno]);
1631                 return;
1632         }
1633
1634         /* Repaint the old "current" line if we be scrolling */
1635         if (ABS(steps) < view->height)
1636                 draw_view_line(view, view->lineno - steps - view->offset);
1637
1638         if (scroll_steps) {
1639                 do_scroll_view(view, scroll_steps);
1640                 return;
1641         }
1642
1643         /* Draw the current line */
1644         draw_view_line(view, view->lineno - view->offset);
1645
1646         redrawwin(view->win);
1647         wrefresh(view->win);
1648         report("");
1649 }
1650
1651
1652 /*
1653  * Searching
1654  */
1655
1656 static void search_view(struct view *view, enum request request);
1657
1658 static bool
1659 find_next_line(struct view *view, unsigned long lineno, struct line *line)
1660 {
1661         assert(view_is_displayed(view));
1662
1663         if (!view->ops->grep(view, line))
1664                 return FALSE;
1665
1666         if (lineno - view->offset >= view->height) {
1667                 view->offset = lineno;
1668                 view->lineno = lineno;
1669                 redraw_view(view);
1670
1671         } else {
1672                 unsigned long old_lineno = view->lineno - view->offset;
1673
1674                 view->lineno = lineno;
1675                 draw_view_line(view, old_lineno);
1676
1677                 draw_view_line(view, view->lineno - view->offset);
1678                 redrawwin(view->win);
1679                 wrefresh(view->win);
1680         }
1681
1682         report("Line %ld matches '%s'", lineno + 1, view->grep);
1683         return TRUE;
1684 }
1685
1686 static void
1687 find_next(struct view *view, enum request request)
1688 {
1689         unsigned long lineno = view->lineno;
1690         int direction;
1691
1692         if (!*view->grep) {
1693                 if (!*opt_search)
1694                         report("No previous search");
1695                 else
1696                         search_view(view, request);
1697                 return;
1698         }
1699
1700         switch (request) {
1701         case REQ_SEARCH:
1702         case REQ_FIND_NEXT:
1703                 direction = 1;
1704                 break;
1705
1706         case REQ_SEARCH_BACK:
1707         case REQ_FIND_PREV:
1708                 direction = -1;
1709                 break;
1710
1711         default:
1712                 return;
1713         }
1714
1715         if (request == REQ_FIND_NEXT || request == REQ_FIND_PREV)
1716                 lineno += direction;
1717
1718         /* Note, lineno is unsigned long so will wrap around in which case it
1719          * will become bigger than view->lines. */
1720         for (; lineno < view->lines; lineno += direction) {
1721                 struct line *line = &view->line[lineno];
1722
1723                 if (find_next_line(view, lineno, line))
1724                         return;
1725         }
1726
1727         report("No match found for '%s'", view->grep);
1728 }
1729
1730 static void
1731 search_view(struct view *view, enum request request)
1732 {
1733         int regex_err;
1734
1735         if (view->regex) {
1736                 regfree(view->regex);
1737                 *view->grep = 0;
1738         } else {
1739                 view->regex = calloc(1, sizeof(*view->regex));
1740                 if (!view->regex)
1741                         return;
1742         }
1743
1744         regex_err = regcomp(view->regex, opt_search, REG_EXTENDED);
1745         if (regex_err != 0) {
1746                 char buf[SIZEOF_STR] = "unknown error";
1747
1748                 regerror(regex_err, view->regex, buf, sizeof(buf));
1749                 report("Search failed: %s", buf);
1750                 return;
1751         }
1752
1753         string_copy(view->grep, opt_search);
1754
1755         find_next(view, request);
1756 }
1757
1758 /*
1759  * Incremental updating
1760  */
1761
1762 static void
1763 end_update(struct view *view)
1764 {
1765         if (!view->pipe)
1766                 return;
1767         set_nonblocking_input(FALSE);
1768         if (view->pipe == stdin)
1769                 fclose(view->pipe);
1770         else
1771                 pclose(view->pipe);
1772         view->pipe = NULL;
1773 }
1774
1775 static bool
1776 begin_update(struct view *view)
1777 {
1778         const char *id = view->id;
1779
1780         if (view->pipe)
1781                 end_update(view);
1782
1783         if (opt_cmd[0]) {
1784                 string_copy(view->cmd, opt_cmd);
1785                 opt_cmd[0] = 0;
1786                 /* When running random commands, initially show the
1787                  * command in the title. However, it maybe later be
1788                  * overwritten if a commit line is selected. */
1789                 string_copy(view->ref, view->cmd);
1790
1791         } else if (view == VIEW(REQ_VIEW_TREE)) {
1792                 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
1793                 char path[SIZEOF_STR];
1794
1795                 if (strcmp(view->vid, view->id))
1796                         opt_path[0] = path[0] = 0;
1797                 else if (sq_quote(path, 0, opt_path) >= sizeof(path))
1798                         return FALSE;
1799
1800                 if (!string_format(view->cmd, format, id, path))
1801                         return FALSE;
1802
1803         } else {
1804                 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
1805
1806                 if (!string_format(view->cmd, format, id, id, id, id, id))
1807                         return FALSE;
1808
1809                 /* Put the current ref_* value to the view title ref
1810                  * member. This is needed by the blob view. Most other
1811                  * views sets it automatically after loading because the
1812                  * first line is a commit line. */
1813                 string_copy(view->ref, id);
1814         }
1815
1816         /* Special case for the pager view. */
1817         if (opt_pipe) {
1818                 view->pipe = opt_pipe;
1819                 opt_pipe = NULL;
1820         } else {
1821                 view->pipe = popen(view->cmd, "r");
1822         }
1823
1824         if (!view->pipe)
1825                 return FALSE;
1826
1827         set_nonblocking_input(TRUE);
1828
1829         view->offset = 0;
1830         view->lines  = 0;
1831         view->lineno = 0;
1832         string_copy(view->vid, id);
1833
1834         if (view->line) {
1835                 int i;
1836
1837                 for (i = 0; i < view->lines; i++)
1838                         if (view->line[i].data)
1839                                 free(view->line[i].data);
1840
1841                 free(view->line);
1842                 view->line = NULL;
1843         }
1844
1845         view->start_time = time(NULL);
1846
1847         return TRUE;
1848 }
1849
1850 static struct line *
1851 realloc_lines(struct view *view, size_t line_size)
1852 {
1853         struct line *tmp = realloc(view->line, sizeof(*view->line) * line_size);
1854
1855         if (!tmp)
1856                 return NULL;
1857
1858         view->line = tmp;
1859         view->line_size = line_size;
1860         return view->line;
1861 }
1862
1863 static bool
1864 update_view(struct view *view)
1865 {
1866         char in_buffer[BUFSIZ];
1867         char out_buffer[BUFSIZ * 2];
1868         char *line;
1869         /* The number of lines to read. If too low it will cause too much
1870          * redrawing (and possible flickering), if too high responsiveness
1871          * will suffer. */
1872         unsigned long lines = view->height;
1873         int redraw_from = -1;
1874
1875         if (!view->pipe)
1876                 return TRUE;
1877
1878         /* Only redraw if lines are visible. */
1879         if (view->offset + view->height >= view->lines)
1880                 redraw_from = view->lines - view->offset;
1881
1882         /* FIXME: This is probably not perfect for backgrounded views. */
1883         if (!realloc_lines(view, view->lines + lines))
1884                 goto alloc_error;
1885
1886         while ((line = fgets(in_buffer, sizeof(in_buffer), view->pipe))) {
1887                 size_t linelen = strlen(line);
1888
1889                 if (linelen)
1890                         line[linelen - 1] = 0;
1891
1892                 if (opt_iconv != ICONV_NONE) {
1893                         char *inbuf = line;
1894                         size_t inlen = linelen;
1895
1896                         char *outbuf = out_buffer;
1897                         size_t outlen = sizeof(out_buffer);
1898
1899                         size_t ret;
1900
1901                         ret = iconv(opt_iconv, &inbuf, &inlen, &outbuf, &outlen);
1902                         if (ret != (size_t) -1) {
1903                                 line = out_buffer;
1904                                 linelen = strlen(out_buffer);
1905                         }
1906                 }
1907
1908                 if (!view->ops->read(view, line))
1909                         goto alloc_error;
1910
1911                 if (lines-- == 1)
1912                         break;
1913         }
1914
1915         {
1916                 int digits;
1917
1918                 lines = view->lines;
1919                 for (digits = 0; lines; digits++)
1920                         lines /= 10;
1921
1922                 /* Keep the displayed view in sync with line number scaling. */
1923                 if (digits != view->digits) {
1924                         view->digits = digits;
1925                         redraw_from = 0;
1926                 }
1927         }
1928
1929         if (!view_is_displayed(view))
1930                 goto check_pipe;
1931
1932         if (view == VIEW(REQ_VIEW_TREE)) {
1933                 /* Clear the view and redraw everything since the tree sorting
1934                  * might have rearranged things. */
1935                 redraw_view(view);
1936
1937         } else if (redraw_from >= 0) {
1938                 /* If this is an incremental update, redraw the previous line
1939                  * since for commits some members could have changed when
1940                  * loading the main view. */
1941                 if (redraw_from > 0)
1942                         redraw_from--;
1943
1944                 /* Since revision graph visualization requires knowledge
1945                  * about the parent commit, it causes a further one-off
1946                  * needed to be redrawn for incremental updates. */
1947                 if (redraw_from > 0 && opt_rev_graph)
1948                         redraw_from--;
1949
1950                 /* Incrementally draw avoids flickering. */
1951                 redraw_view_from(view, redraw_from);
1952         }
1953
1954         /* Update the title _after_ the redraw so that if the redraw picks up a
1955          * commit reference in view->ref it'll be available here. */
1956         update_view_title(view);
1957
1958 check_pipe:
1959         if (ferror(view->pipe)) {
1960                 report("Failed to read: %s", strerror(errno));
1961                 goto end;
1962
1963         } else if (feof(view->pipe)) {
1964                 report("");
1965                 goto end;
1966         }
1967
1968         return TRUE;
1969
1970 alloc_error:
1971         report("Allocation failure");
1972
1973 end:
1974         view->ops->read(view, NULL);
1975         end_update(view);
1976         return FALSE;
1977 }
1978
1979 static struct line *
1980 add_line_text(struct view *view, char *data, enum line_type type)
1981 {
1982         struct line *line = &view->line[view->lines];
1983
1984         if (!data)
1985                 return NULL;
1986
1987         line->data = strdup(data);
1988         if (!line->data)
1989                 return NULL;
1990
1991         line->type = type;
1992         view->lines++;
1993
1994         return line;
1995 }
1996
1997
1998 /*
1999  * View opening
2000  */
2001
2002 static void open_help_view(struct view *view)
2003 {
2004         char buf[BUFSIZ];
2005         int lines = ARRAY_SIZE(req_info) + 2;
2006         int i;
2007
2008         if (view->lines > 0)
2009                 return;
2010
2011         for (i = 0; i < ARRAY_SIZE(req_info); i++)
2012                 if (!req_info[i].request)
2013                         lines++;
2014
2015         view->line = calloc(lines, sizeof(*view->line));
2016         if (!view->line) {
2017                 report("Allocation failure");
2018                 return;
2019         }
2020
2021         add_line_text(view, "Quick reference for tig keybindings:", LINE_DEFAULT);
2022
2023         for (i = 0; i < ARRAY_SIZE(req_info); i++) {
2024                 char *key;
2025
2026                 if (!req_info[i].request) {
2027                         add_line_text(view, "", LINE_DEFAULT);
2028                         add_line_text(view, req_info[i].help, LINE_DEFAULT);
2029                         continue;
2030                 }
2031
2032                 key = get_key(req_info[i].request);
2033                 if (!string_format(buf, "    %-25s %s", key, req_info[i].help))
2034                         continue;
2035
2036                 add_line_text(view, buf, LINE_DEFAULT);
2037         }
2038 }
2039
2040 enum open_flags {
2041         OPEN_DEFAULT = 0,       /* Use default view switching. */
2042         OPEN_SPLIT = 1,         /* Split current view. */
2043         OPEN_BACKGROUNDED = 2,  /* Backgrounded. */
2044         OPEN_RELOAD = 4,        /* Reload view even if it is the current. */
2045 };
2046
2047 static void
2048 open_view(struct view *prev, enum request request, enum open_flags flags)
2049 {
2050         bool backgrounded = !!(flags & OPEN_BACKGROUNDED);
2051         bool split = !!(flags & OPEN_SPLIT);
2052         bool reload = !!(flags & OPEN_RELOAD);
2053         struct view *view = VIEW(request);
2054         int nviews = displayed_views();
2055         struct view *base_view = display[0];
2056
2057         if (view == prev && nviews == 1 && !reload) {
2058                 report("Already in %s view", view->name);
2059                 return;
2060         }
2061
2062         if (view == VIEW(REQ_VIEW_HELP)) {
2063                 open_help_view(view);
2064
2065         } else if ((reload || strcmp(view->vid, view->id)) &&
2066                    !begin_update(view)) {
2067                 report("Failed to load %s view", view->name);
2068                 return;
2069         }
2070
2071         if (split) {
2072                 display[1] = view;
2073                 if (!backgrounded)
2074                         current_view = 1;
2075         } else {
2076                 /* Maximize the current view. */
2077                 memset(display, 0, sizeof(display));
2078                 current_view = 0;
2079                 display[current_view] = view;
2080         }
2081
2082         /* Resize the view when switching between split- and full-screen,
2083          * or when switching between two different full-screen views. */
2084         if (nviews != displayed_views() ||
2085             (nviews == 1 && base_view != display[0]))
2086                 resize_display();
2087
2088         if (split && prev->lineno - prev->offset >= prev->height) {
2089                 /* Take the title line into account. */
2090                 int lines = prev->lineno - prev->offset - prev->height + 1;
2091
2092                 /* Scroll the view that was split if the current line is
2093                  * outside the new limited view. */
2094                 do_scroll_view(prev, lines);
2095         }
2096
2097         if (prev && view != prev) {
2098                 if (split && !backgrounded) {
2099                         /* "Blur" the previous view. */
2100                         update_view_title(prev);
2101                 }
2102
2103                 view->parent = prev;
2104         }
2105
2106         if (view->pipe && view->lines == 0) {
2107                 /* Clear the old view and let the incremental updating refill
2108                  * the screen. */
2109                 wclear(view->win);
2110                 report("");
2111         } else {
2112                 redraw_view(view);
2113                 report("");
2114         }
2115
2116         /* If the view is backgrounded the above calls to report()
2117          * won't redraw the view title. */
2118         if (backgrounded)
2119                 update_view_title(view);
2120 }
2121
2122
2123 /*
2124  * User request switch noodle
2125  */
2126
2127 static int
2128 view_driver(struct view *view, enum request request)
2129 {
2130         int i;
2131
2132         switch (request) {
2133         case REQ_MOVE_UP:
2134         case REQ_MOVE_DOWN:
2135         case REQ_MOVE_PAGE_UP:
2136         case REQ_MOVE_PAGE_DOWN:
2137         case REQ_MOVE_FIRST_LINE:
2138         case REQ_MOVE_LAST_LINE:
2139                 move_view(view, request);
2140                 break;
2141
2142         case REQ_SCROLL_LINE_DOWN:
2143         case REQ_SCROLL_LINE_UP:
2144         case REQ_SCROLL_PAGE_DOWN:
2145         case REQ_SCROLL_PAGE_UP:
2146                 scroll_view(view, request);
2147                 break;
2148
2149         case REQ_VIEW_BLOB:
2150                 if (!ref_blob[0]) {
2151                         report("No file chosen, press 't' to open tree view");
2152                         break;
2153                 }
2154                 /* Fall-through */
2155         case REQ_VIEW_MAIN:
2156         case REQ_VIEW_DIFF:
2157         case REQ_VIEW_LOG:
2158         case REQ_VIEW_TREE:
2159         case REQ_VIEW_HELP:
2160         case REQ_VIEW_PAGER:
2161                 open_view(view, request, OPEN_DEFAULT);
2162                 break;
2163
2164         case REQ_NEXT:
2165         case REQ_PREVIOUS:
2166                 request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
2167
2168                 if ((view == VIEW(REQ_VIEW_DIFF) &&
2169                      view->parent == VIEW(REQ_VIEW_MAIN)) ||
2170                    (view == VIEW(REQ_VIEW_BLOB) &&
2171                      view->parent == VIEW(REQ_VIEW_TREE))) {
2172                         view = view->parent;
2173                         move_view(view, request);
2174                         if (view_is_displayed(view))
2175                                 update_view_title(view);
2176                 } else {
2177                         move_view(view, request);
2178                         break;
2179                 }
2180                 /* Fall-through */
2181
2182         case REQ_ENTER:
2183                 if (!view->lines) {
2184                         report("Nothing to enter");
2185                         break;
2186                 }
2187                 return view->ops->enter(view, &view->line[view->lineno]);
2188
2189         case REQ_VIEW_NEXT:
2190         {
2191                 int nviews = displayed_views();
2192                 int next_view = (current_view + 1) % nviews;
2193
2194                 if (next_view == current_view) {
2195                         report("Only one view is displayed");
2196                         break;
2197                 }
2198
2199                 current_view = next_view;
2200                 /* Blur out the title of the previous view. */
2201                 update_view_title(view);
2202                 report("");
2203                 break;
2204         }
2205         case REQ_TOGGLE_LINENO:
2206                 opt_line_number = !opt_line_number;
2207                 redraw_display();
2208                 break;
2209
2210         case REQ_TOGGLE_REV_GRAPH:
2211                 opt_rev_graph = !opt_rev_graph;
2212                 redraw_display();
2213                 break;
2214
2215         case REQ_PROMPT:
2216                 /* Always reload^Wrerun commands from the prompt. */
2217                 open_view(view, opt_request, OPEN_RELOAD);
2218                 break;
2219
2220         case REQ_SEARCH:
2221         case REQ_SEARCH_BACK:
2222                 search_view(view, request);
2223                 break;
2224
2225         case REQ_FIND_NEXT:
2226         case REQ_FIND_PREV:
2227                 find_next(view, request);
2228                 break;
2229
2230         case REQ_STOP_LOADING:
2231                 for (i = 0; i < ARRAY_SIZE(views); i++) {
2232                         view = &views[i];
2233                         if (view->pipe)
2234                                 report("Stopped loading the %s view", view->name),
2235                         end_update(view);
2236                 }
2237                 break;
2238
2239         case REQ_SHOW_VERSION:
2240                 report("%s (built %s)", VERSION, __DATE__);
2241                 return TRUE;
2242
2243         case REQ_SCREEN_RESIZE:
2244                 resize_display();
2245                 /* Fall-through */
2246         case REQ_SCREEN_REDRAW:
2247                 redraw_display();
2248                 break;
2249
2250         case REQ_NONE:
2251                 doupdate();
2252                 return TRUE;
2253
2254         case REQ_VIEW_CLOSE:
2255                 /* XXX: Mark closed views by letting view->parent point to the
2256                  * view itself. Parents to closed view should never be
2257                  * followed. */
2258                 if (view->parent &&
2259                     view->parent->parent != view->parent) {
2260                         memset(display, 0, sizeof(display));
2261                         current_view = 0;
2262                         display[current_view] = view->parent;
2263                         view->parent = view;
2264                         resize_display();
2265                         redraw_display();
2266                         break;
2267                 }
2268                 /* Fall-through */
2269         case REQ_QUIT:
2270                 return FALSE;
2271
2272         default:
2273                 /* An unknown key will show most commonly used commands. */
2274                 report("Unknown key, press 'h' for help");
2275                 return TRUE;
2276         }
2277
2278         return TRUE;
2279 }
2280
2281
2282 /*
2283  * Pager backend
2284  */
2285
2286 static bool
2287 pager_draw(struct view *view, struct line *line, unsigned int lineno, bool selected)
2288 {
2289         char *text = line->data;
2290         enum line_type type = line->type;
2291         int textlen = strlen(text);
2292         int attr;
2293
2294         wmove(view->win, lineno, 0);
2295
2296         if (selected) {
2297                 type = LINE_CURSOR;
2298                 wchgat(view->win, -1, 0, type, NULL);
2299         }
2300
2301         attr = get_line_attr(type);
2302         wattrset(view->win, attr);
2303
2304         if (opt_line_number || opt_tab_size < TABSIZE) {
2305                 static char spaces[] = "                    ";
2306                 int col_offset = 0, col = 0;
2307
2308                 if (opt_line_number) {
2309                         unsigned long real_lineno = view->offset + lineno + 1;
2310
2311                         if (real_lineno == 1 ||
2312                             (real_lineno % opt_num_interval) == 0) {
2313                                 wprintw(view->win, "%.*d", view->digits, real_lineno);
2314
2315                         } else {
2316                                 waddnstr(view->win, spaces,
2317                                          MIN(view->digits, STRING_SIZE(spaces)));
2318                         }
2319                         waddstr(view->win, ": ");
2320                         col_offset = view->digits + 2;
2321                 }
2322
2323                 while (text && col_offset + col < view->width) {
2324                         int cols_max = view->width - col_offset - col;
2325                         char *pos = text;
2326                         int cols;
2327
2328                         if (*text == '\t') {
2329                                 text++;
2330                                 assert(sizeof(spaces) > TABSIZE);
2331                                 pos = spaces;
2332                                 cols = opt_tab_size - (col % opt_tab_size);
2333
2334                         } else {
2335                                 text = strchr(text, '\t');
2336                                 cols = line ? text - pos : strlen(pos);
2337                         }
2338
2339                         waddnstr(view->win, pos, MIN(cols, cols_max));
2340                         col += cols;
2341                 }
2342
2343         } else {
2344                 int col = 0, pos = 0;
2345
2346                 for (; pos < textlen && col < view->width; pos++, col++)
2347                         if (text[pos] == '\t')
2348                                 col += TABSIZE - (col % TABSIZE) - 1;
2349
2350                 waddnstr(view->win, text, pos);
2351         }
2352
2353         return TRUE;
2354 }
2355
2356 static bool
2357 add_describe_ref(char *buf, size_t *bufpos, char *commit_id, const char *sep)
2358 {
2359         char refbuf[SIZEOF_STR];
2360         char *ref = NULL;
2361         FILE *pipe;
2362
2363         if (!string_format(refbuf, "git describe %s 2>/dev/null", commit_id))
2364                 return TRUE;
2365
2366         pipe = popen(refbuf, "r");
2367         if (!pipe)
2368                 return TRUE;
2369
2370         if ((ref = fgets(refbuf, sizeof(refbuf), pipe)))
2371                 ref = chomp_string(ref);
2372         pclose(pipe);
2373
2374         if (!ref || !*ref)
2375                 return TRUE;
2376
2377         /* This is the only fatal call, since it can "corrupt" the buffer. */
2378         if (!string_nformat(buf, SIZEOF_STR, bufpos, "%s%s", sep, ref))
2379                 return FALSE;
2380
2381         return TRUE;
2382 }
2383
2384 static void
2385 add_pager_refs(struct view *view, struct line *line)
2386 {
2387         char buf[SIZEOF_STR];
2388         char *commit_id = line->data + STRING_SIZE("commit ");
2389         struct ref **refs;
2390         size_t bufpos = 0, refpos = 0;
2391         const char *sep = "Refs: ";
2392         bool is_tag = FALSE;
2393
2394         assert(line->type == LINE_COMMIT);
2395
2396         refs = get_refs(commit_id);
2397         if (!refs) {
2398                 if (view == VIEW(REQ_VIEW_DIFF))
2399                         goto try_add_describe_ref;
2400                 return;
2401         }
2402
2403         do {
2404                 struct ref *ref = refs[refpos];
2405                 char *fmt = ref->tag    ? "%s[%s]" :
2406                             ref->remote ? "%s<%s>" : "%s%s";
2407
2408                 if (!string_format_from(buf, &bufpos, fmt, sep, ref->name))
2409                         return;
2410                 sep = ", ";
2411                 if (ref->tag)
2412                         is_tag = TRUE;
2413         } while (refs[refpos++]->next);
2414
2415         if (!is_tag && view == VIEW(REQ_VIEW_DIFF)) {
2416 try_add_describe_ref:
2417                 /* Add <tag>-g<commit_id> "fake" reference. */
2418                 if (!add_describe_ref(buf, &bufpos, commit_id, sep))
2419                         return;
2420         }
2421
2422         if (bufpos == 0)
2423                 return;
2424
2425         if (!realloc_lines(view, view->line_size + 1))
2426                 return;
2427
2428         add_line_text(view, buf, LINE_PP_REFS);
2429 }
2430
2431 static bool
2432 pager_read(struct view *view, char *data)
2433 {
2434         struct line *line;
2435
2436         if (!data)
2437                 return TRUE;
2438
2439         line = add_line_text(view, data, get_line_type(data));
2440         if (!line)
2441                 return FALSE;
2442
2443         if (line->type == LINE_COMMIT &&
2444             (view == VIEW(REQ_VIEW_DIFF) ||
2445              view == VIEW(REQ_VIEW_LOG)))
2446                 add_pager_refs(view, line);
2447
2448         return TRUE;
2449 }
2450
2451 static bool
2452 pager_enter(struct view *view, struct line *line)
2453 {
2454         int split = 0;
2455
2456         if (line->type == LINE_COMMIT &&
2457            (view == VIEW(REQ_VIEW_LOG) ||
2458             view == VIEW(REQ_VIEW_PAGER))) {
2459                 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
2460                 split = 1;
2461         }
2462
2463         /* Always scroll the view even if it was split. That way
2464          * you can use Enter to scroll through the log view and
2465          * split open each commit diff. */
2466         scroll_view(view, REQ_SCROLL_LINE_DOWN);
2467
2468         /* FIXME: A minor workaround. Scrolling the view will call report("")
2469          * but if we are scrolling a non-current view this won't properly
2470          * update the view title. */
2471         if (split)
2472                 update_view_title(view);
2473
2474         return TRUE;
2475 }
2476
2477 static bool
2478 pager_grep(struct view *view, struct line *line)
2479 {
2480         regmatch_t pmatch;
2481         char *text = line->data;
2482
2483         if (!*text)
2484                 return FALSE;
2485
2486         if (regexec(view->regex, text, 1, &pmatch, 0) == REG_NOMATCH)
2487                 return FALSE;
2488
2489         return TRUE;
2490 }
2491
2492 static void
2493 pager_select(struct view *view, struct line *line)
2494 {
2495         if (line->type == LINE_COMMIT) {
2496                 char *text = line->data + STRING_SIZE("commit ");
2497
2498                 if (view != VIEW(REQ_VIEW_PAGER))
2499                         string_copy(view->ref, text);
2500                 string_copy(ref_commit, text);
2501         }
2502 }
2503
2504 static struct view_ops pager_ops = {
2505         "line",
2506         pager_draw,
2507         pager_read,
2508         pager_enter,
2509         pager_grep,
2510         pager_select,
2511 };
2512
2513
2514 /*
2515  * Tree backend
2516  */
2517
2518 /* Parse output from git-ls-tree(1):
2519  *
2520  * 100644 blob fb0e31ea6cc679b7379631188190e975f5789c26 Makefile
2521  * 100644 blob 5304ca4260aaddaee6498f9630e7d471b8591ea6 README
2522  * 100644 blob f931e1d229c3e185caad4449bf5b66ed72462657 tig.c
2523  * 100644 blob ed09fe897f3c7c9af90bcf80cae92558ea88ae38 web.conf
2524  */
2525
2526 #define SIZEOF_TREE_ATTR \
2527         STRING_SIZE("100644 blob ed09fe897f3c7c9af90bcf80cae92558ea88ae38\t")
2528
2529 #define TREE_UP_FORMAT "040000 tree %s\t.."
2530
2531 static int
2532 tree_compare_entry(enum line_type type1, char *name1,
2533                    enum line_type type2, char *name2)
2534 {
2535         if (type1 != type2) {
2536                 if (type1 == LINE_TREE_DIR)
2537                         return -1;
2538                 return 1;
2539         }
2540
2541         return strcmp(name1, name2);
2542 }
2543
2544 static bool
2545 tree_read(struct view *view, char *text)
2546 {
2547         size_t textlen = text ? strlen(text) : 0;
2548         char buf[SIZEOF_STR];
2549         unsigned long pos;
2550         enum line_type type;
2551         bool first_read = view->lines == 0;
2552
2553         if (textlen <= SIZEOF_TREE_ATTR)
2554                 return FALSE;
2555
2556         type = text[STRING_SIZE("100644 ")] == 't'
2557              ? LINE_TREE_DIR : LINE_TREE_FILE;
2558
2559         if (first_read) {
2560                 /* Add path info line */
2561                 if (!string_format(buf, "Directory path /%s", opt_path) ||
2562                     !realloc_lines(view, view->line_size + 1) ||
2563                     !add_line_text(view, buf, LINE_DEFAULT))
2564                         return FALSE;
2565
2566                 /* Insert "link" to parent directory. */
2567                 if (*opt_path) {
2568                         if (!string_format(buf, TREE_UP_FORMAT, view->ref) ||
2569                             !realloc_lines(view, view->line_size + 1) ||
2570                             !add_line_text(view, buf, LINE_TREE_DIR))
2571                                 return FALSE;
2572                 }
2573         }
2574
2575         /* Strip the path part ... */
2576         if (*opt_path) {
2577                 size_t pathlen = textlen - SIZEOF_TREE_ATTR;
2578                 size_t striplen = strlen(opt_path);
2579                 char *path = text + SIZEOF_TREE_ATTR;
2580
2581                 if (pathlen > striplen)
2582                         memmove(path, path + striplen,
2583                                 pathlen - striplen + 1);
2584         }
2585
2586         /* Skip "Directory ..." and ".." line. */
2587         for (pos = 1 + !!*opt_path; pos < view->lines; pos++) {
2588                 struct line *line = &view->line[pos];
2589                 char *path1 = ((char *) line->data) + SIZEOF_TREE_ATTR;
2590                 char *path2 = text + SIZEOF_TREE_ATTR;
2591                 int cmp = tree_compare_entry(line->type, path1, type, path2);
2592
2593                 if (cmp <= 0)
2594                         continue;
2595
2596                 text = strdup(text);
2597                 if (!text)
2598                         return FALSE;
2599
2600                 if (view->lines > pos)
2601                         memmove(&view->line[pos + 1], &view->line[pos],
2602                                 (view->lines - pos) * sizeof(*line));
2603
2604                 line = &view->line[pos];
2605                 line->data = text;
2606                 line->type = type;
2607                 view->lines++;
2608                 return TRUE;
2609         }
2610
2611         if (!add_line_text(view, text, type))
2612                 return FALSE;
2613
2614         /* Move the current line to the first tree entry. */
2615         if (first_read)
2616                 view->lineno++;
2617
2618         return TRUE;
2619 }
2620
2621 static bool
2622 tree_enter(struct view *view, struct line *line)
2623 {
2624         enum open_flags flags;
2625         enum request request;
2626
2627         switch (line->type) {
2628         case LINE_TREE_DIR:
2629                 /* Depending on whether it is a subdir or parent (updir?) link
2630                  * mangle the path buffer. */
2631                 if (line == &view->line[1] && *opt_path) {
2632                         size_t path_len = strlen(opt_path);
2633                         char *dirsep = opt_path + path_len - 1;
2634
2635                         while (dirsep > opt_path && dirsep[-1] != '/')
2636                                 dirsep--;
2637
2638                         dirsep[0] = 0;
2639
2640                 } else {
2641                         size_t pathlen = strlen(opt_path);
2642                         size_t origlen = pathlen;
2643                         char *data = line->data;
2644                         char *basename = data + SIZEOF_TREE_ATTR;
2645
2646                         if (!string_format_from(opt_path, &pathlen, "%s/", basename)) {
2647                                 opt_path[origlen] = 0;
2648                                 return TRUE;
2649                         }
2650                 }
2651
2652                 /* Trees and subtrees share the same ID, so they are not not
2653                  * unique like blobs. */
2654                 flags = OPEN_RELOAD;
2655                 request = REQ_VIEW_TREE;
2656                 break;
2657
2658         case LINE_TREE_FILE:
2659                 flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
2660                 request = REQ_VIEW_BLOB;
2661                 break;
2662
2663         default:
2664                 return TRUE;
2665         }
2666
2667         open_view(view, request, flags);
2668
2669         return TRUE;
2670 }
2671
2672 static void
2673 tree_select(struct view *view, struct line *line)
2674 {
2675         char *text = line->data + STRING_SIZE("100644 blob ");
2676
2677         if (line->type == LINE_TREE_FILE) {
2678                 string_ncopy(ref_blob, text, 40);
2679
2680         } else if (line->type != LINE_TREE_DIR) {
2681                 return;
2682         }
2683
2684         string_ncopy(view->ref, text, 40);
2685 }
2686
2687 static struct view_ops tree_ops = {
2688         "file",
2689         pager_draw,
2690         tree_read,
2691         tree_enter,
2692         pager_grep,
2693         tree_select,
2694 };
2695
2696 static bool
2697 blob_read(struct view *view, char *line)
2698 {
2699         return add_line_text(view, line, LINE_DEFAULT);
2700 }
2701
2702 static struct view_ops blob_ops = {
2703         "line",
2704         pager_draw,
2705         blob_read,
2706         pager_enter,
2707         pager_grep,
2708         pager_select,
2709 };
2710
2711
2712 /*
2713  * Revision graph
2714  */
2715
2716 struct commit {
2717         char id[SIZEOF_REV];            /* SHA1 ID. */
2718         char title[128];                /* First line of the commit message. */
2719         char author[75];                /* Author of the commit. */
2720         struct tm time;                 /* Date from the author ident. */
2721         struct ref **refs;              /* Repository references. */
2722         chtype graph[SIZEOF_REVGRAPH];  /* Ancestry chain graphics. */
2723         size_t graph_size;              /* The width of the graph array. */
2724 };
2725
2726 /* Size of rev graph with no  "padding" columns */
2727 #define SIZEOF_REVITEMS (SIZEOF_REVGRAPH - (SIZEOF_REVGRAPH / 2))
2728
2729 struct rev_graph {
2730         struct rev_graph *prev, *next, *parents;
2731         char rev[SIZEOF_REVITEMS][SIZEOF_REV];
2732         size_t size;
2733         struct commit *commit;
2734         size_t pos;
2735 };
2736
2737 /* Parents of the commit being visualized. */
2738 static struct rev_graph graph_parents[4];
2739
2740 /* The current stack of revisions on the graph. */
2741 static struct rev_graph graph_stacks[4] = {
2742         { &graph_stacks[3], &graph_stacks[1], &graph_parents[0] },
2743         { &graph_stacks[0], &graph_stacks[2], &graph_parents[1] },
2744         { &graph_stacks[1], &graph_stacks[3], &graph_parents[2] },
2745         { &graph_stacks[2], &graph_stacks[0], &graph_parents[3] },
2746 };
2747
2748 static inline bool
2749 graph_parent_is_merge(struct rev_graph *graph)
2750 {
2751         return graph->parents->size > 1;
2752 }
2753
2754 static inline void
2755 append_to_rev_graph(struct rev_graph *graph, chtype symbol)
2756 {
2757         struct commit *commit = graph->commit;
2758
2759         if (commit->graph_size < ARRAY_SIZE(commit->graph) - 1)
2760                 commit->graph[commit->graph_size++] = symbol;
2761 }
2762
2763 static void
2764 done_rev_graph(struct rev_graph *graph)
2765 {
2766         if (graph_parent_is_merge(graph) &&
2767             graph->pos < graph->size - 1 &&
2768             graph->next->size == graph->size + graph->parents->size - 1) {
2769                 size_t i = graph->pos + graph->parents->size - 1;
2770
2771                 graph->commit->graph_size = i * 2;
2772                 while (i < graph->next->size - 1) {
2773                         append_to_rev_graph(graph, ' ');
2774                         append_to_rev_graph(graph, '\\');
2775                         i++;
2776                 }
2777         }
2778
2779         graph->size = graph->pos = 0;
2780         graph->commit = NULL;
2781         memset(graph->parents, 0, sizeof(*graph->parents));
2782 }
2783
2784 static void
2785 push_rev_graph(struct rev_graph *graph, char *parent)
2786 {
2787         int i;
2788
2789         /* "Collapse" duplicate parents lines.
2790          *
2791          * FIXME: This needs to also update update the drawn graph but
2792          * for now it just serves as a method for pruning graph lines. */
2793         for (i = 0; i < graph->size; i++)
2794                 if (!strncmp(graph->rev[i], parent, SIZEOF_REV))
2795                         return;
2796
2797         if (graph->size < SIZEOF_REVITEMS) {
2798                 string_ncopy(graph->rev[graph->size++], parent, SIZEOF_REV);
2799         }
2800 }
2801
2802 static chtype
2803 get_rev_graph_symbol(struct rev_graph *graph)
2804 {
2805         chtype symbol;
2806
2807         if (graph->parents->size == 0)
2808                 symbol = REVGRAPH_INIT;
2809         else if (graph_parent_is_merge(graph))
2810                 symbol = REVGRAPH_MERGE;
2811         else if (graph->pos >= graph->size)
2812                 symbol = REVGRAPH_BRANCH;
2813         else
2814                 symbol = REVGRAPH_COMMIT;
2815
2816         return symbol;
2817 }
2818
2819 static void
2820 draw_rev_graph(struct rev_graph *graph)
2821 {
2822         struct rev_filler {
2823                 chtype separator, line;
2824         };
2825         enum { DEFAULT, RSHARP, RDIAG, LDIAG };
2826         static struct rev_filler fillers[] = {
2827                 { ' ',  REVGRAPH_LINE },
2828                 { '`',  '.' },
2829                 { '\'', ' ' },
2830                 { '/',  ' ' },
2831         };
2832         chtype symbol = get_rev_graph_symbol(graph);
2833         struct rev_filler *filler;
2834         size_t i;
2835
2836         filler = &fillers[DEFAULT];
2837
2838         for (i = 0; i < graph->pos; i++) {
2839                 append_to_rev_graph(graph, filler->line);
2840                 if (graph_parent_is_merge(graph->prev) &&
2841                     graph->prev->pos == i)
2842                         filler = &fillers[RSHARP];
2843
2844                 append_to_rev_graph(graph, filler->separator);
2845         }
2846
2847         /* Place the symbol for this revision. */
2848         append_to_rev_graph(graph, symbol);
2849
2850         if (graph->prev->size > graph->size)
2851                 filler = &fillers[RDIAG];
2852         else
2853                 filler = &fillers[DEFAULT];
2854
2855         i++;
2856
2857         for (; i < graph->size; i++) {
2858                 append_to_rev_graph(graph, filler->separator);
2859                 append_to_rev_graph(graph, filler->line);
2860                 if (graph_parent_is_merge(graph->prev) &&
2861                     i < graph->prev->pos + graph->parents->size)
2862                         filler = &fillers[RSHARP];
2863                 if (graph->prev->size > graph->size)
2864                         filler = &fillers[LDIAG];
2865         }
2866
2867         if (graph->prev->size > graph->size) {
2868                 append_to_rev_graph(graph, filler->separator);
2869                 if (filler->line != ' ')
2870                         append_to_rev_graph(graph, filler->line);
2871         }
2872 }
2873
2874 /* Prepare the next rev graph */
2875 static void
2876 prepare_rev_graph(struct rev_graph *graph)
2877 {
2878         size_t i;
2879
2880         /* First, traverse all lines of revisions up to the active one. */
2881         for (graph->pos = 0; graph->pos < graph->size; graph->pos++) {
2882                 if (!strcmp(graph->rev[graph->pos], graph->commit->id))
2883                         break;
2884
2885                 push_rev_graph(graph->next, graph->rev[graph->pos]);
2886         }
2887
2888         /* Interleave the new revision parent(s). */
2889         for (i = 0; i < graph->parents->size; i++)
2890                 push_rev_graph(graph->next, graph->parents->rev[i]);
2891
2892         /* Lastly, put any remaining revisions. */
2893         for (i = graph->pos + 1; i < graph->size; i++)
2894                 push_rev_graph(graph->next, graph->rev[i]);
2895 }
2896
2897 static void
2898 update_rev_graph(struct rev_graph *graph)
2899 {
2900         /* If this is the finalizing update ... */
2901         if (graph->commit)
2902                 prepare_rev_graph(graph);
2903
2904         /* Graph visualization needs a one rev look-ahead,
2905          * so the first update doesn't visualize anything. */
2906         if (!graph->prev->commit)
2907                 return;
2908
2909         draw_rev_graph(graph->prev);
2910         done_rev_graph(graph->prev->prev);
2911 }
2912
2913
2914 /*
2915  * Main view backend
2916  */
2917
2918 static bool
2919 main_draw(struct view *view, struct line *line, unsigned int lineno, bool selected)
2920 {
2921         char buf[DATE_COLS + 1];
2922         struct commit *commit = line->data;
2923         enum line_type type;
2924         int col = 0;
2925         size_t timelen;
2926         size_t authorlen;
2927         int trimmed = 1;
2928
2929         if (!*commit->author)
2930                 return FALSE;
2931
2932         wmove(view->win, lineno, col);
2933
2934         if (selected) {
2935                 type = LINE_CURSOR;
2936                 wattrset(view->win, get_line_attr(type));
2937                 wchgat(view->win, -1, 0, type, NULL);
2938
2939         } else {
2940                 type = LINE_MAIN_COMMIT;
2941                 wattrset(view->win, get_line_attr(LINE_MAIN_DATE));
2942         }
2943
2944         timelen = strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time);
2945         waddnstr(view->win, buf, timelen);
2946         waddstr(view->win, " ");
2947
2948         col += DATE_COLS;
2949         wmove(view->win, lineno, col);
2950         if (type != LINE_CURSOR)
2951                 wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
2952
2953         if (opt_utf8) {
2954                 authorlen = utf8_length(commit->author, AUTHOR_COLS - 2, &col, &trimmed);
2955         } else {
2956                 authorlen = strlen(commit->author);
2957                 if (authorlen > AUTHOR_COLS - 2) {
2958                         authorlen = AUTHOR_COLS - 2;
2959                         trimmed = 1;
2960                 }
2961         }
2962
2963         if (trimmed) {
2964                 waddnstr(view->win, commit->author, authorlen);
2965                 if (type != LINE_CURSOR)
2966                         wattrset(view->win, get_line_attr(LINE_MAIN_DELIM));
2967                 waddch(view->win, '~');
2968         } else {
2969                 waddstr(view->win, commit->author);
2970         }
2971
2972         col += AUTHOR_COLS;
2973         if (type != LINE_CURSOR)
2974                 wattrset(view->win, A_NORMAL);
2975
2976         if (opt_rev_graph && commit->graph_size) {
2977                 size_t i;
2978
2979                 wmove(view->win, lineno, col);
2980                 /* Using waddch() instead of waddnstr() ensures that
2981                  * they'll be rendered correctly for the cursor line. */
2982                 for (i = 0; i < commit->graph_size; i++)
2983                         waddch(view->win, commit->graph[i]);
2984
2985                 waddch(view->win, ' ');
2986                 col += commit->graph_size + 1;
2987         }
2988
2989         wmove(view->win, lineno, col);
2990
2991         if (commit->refs) {
2992                 size_t i = 0;
2993
2994                 do {
2995                         if (type == LINE_CURSOR)
2996                                 ;
2997                         else if (commit->refs[i]->tag)
2998                                 wattrset(view->win, get_line_attr(LINE_MAIN_TAG));
2999                         else if (commit->refs[i]->remote)
3000                                 wattrset(view->win, get_line_attr(LINE_MAIN_REMOTE));
3001                         else
3002                                 wattrset(view->win, get_line_attr(LINE_MAIN_REF));
3003                         waddstr(view->win, "[");
3004                         waddstr(view->win, commit->refs[i]->name);
3005                         waddstr(view->win, "]");
3006                         if (type != LINE_CURSOR)
3007                                 wattrset(view->win, A_NORMAL);
3008                         waddstr(view->win, " ");
3009                         col += strlen(commit->refs[i]->name) + STRING_SIZE("[] ");
3010                 } while (commit->refs[i++]->next);
3011         }
3012
3013         if (type != LINE_CURSOR)
3014                 wattrset(view->win, get_line_attr(type));
3015
3016         {
3017                 int titlelen = strlen(commit->title);
3018
3019                 if (col + titlelen > view->width)
3020                         titlelen = view->width - col;
3021
3022                 waddnstr(view->win, commit->title, titlelen);
3023         }
3024
3025         return TRUE;
3026 }
3027
3028 /* Reads git log --pretty=raw output and parses it into the commit struct. */
3029 static bool
3030 main_read(struct view *view, char *line)
3031 {
3032         static struct rev_graph *graph = graph_stacks;
3033         enum line_type type;
3034         struct commit *commit = view->lines
3035                               ? view->line[view->lines - 1].data : NULL;
3036
3037         if (!line) {
3038                 update_rev_graph(graph);
3039                 return TRUE;
3040         }
3041
3042         type = get_line_type(line);
3043
3044         switch (type) {
3045         case LINE_COMMIT:
3046                 commit = calloc(1, sizeof(struct commit));
3047                 if (!commit)
3048                         return FALSE;
3049
3050                 line += STRING_SIZE("commit ");
3051
3052                 view->line[view->lines++].data = commit;
3053                 string_copy(commit->id, line);
3054                 commit->refs = get_refs(commit->id);
3055                 graph->commit = commit;
3056                 break;
3057
3058         case LINE_PARENT:
3059                 if (commit) {
3060                         line += STRING_SIZE("parent ");
3061                         push_rev_graph(graph->parents, line);
3062                 }
3063                 break;
3064
3065         case LINE_AUTHOR:
3066         {
3067                 /* Parse author lines where the name may be empty:
3068                  *      author  <email@address.tld> 1138474660 +0100
3069                  */
3070                 char *ident = line + STRING_SIZE("author ");
3071                 char *nameend = strchr(ident, '<');
3072                 char *emailend = strchr(ident, '>');
3073
3074                 if (!commit || !nameend || !emailend)
3075                         break;
3076
3077                 update_rev_graph(graph);
3078                 graph = graph->next;
3079
3080                 *nameend = *emailend = 0;
3081                 ident = chomp_string(ident);
3082                 if (!*ident) {
3083                         ident = chomp_string(nameend + 1);
3084                         if (!*ident)
3085                                 ident = "Unknown";
3086                 }
3087
3088                 string_copy(commit->author, ident);
3089
3090                 /* Parse epoch and timezone */
3091                 if (emailend[1] == ' ') {
3092                         char *secs = emailend + 2;
3093                         char *zone = strchr(secs, ' ');
3094                         time_t time = (time_t) atol(secs);
3095
3096                         if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
3097                                 long tz;
3098
3099                                 zone++;
3100                                 tz  = ('0' - zone[1]) * 60 * 60 * 10;
3101                                 tz += ('0' - zone[2]) * 60 * 60;
3102                                 tz += ('0' - zone[3]) * 60;
3103                                 tz += ('0' - zone[4]) * 60;
3104
3105                                 if (zone[0] == '-')
3106                                         tz = -tz;
3107
3108                                 time -= tz;
3109                         }
3110
3111                         gmtime_r(&time, &commit->time);
3112                 }
3113                 break;
3114         }
3115         default:
3116                 if (!commit)
3117                         break;
3118
3119                 /* Fill in the commit title if it has not already been set. */
3120                 if (commit->title[0])
3121                         break;
3122
3123                 /* Require titles to start with a non-space character at the
3124                  * offset used by git log. */
3125                 if (strncmp(line, "    ", 4))
3126                         break;
3127                 line += 4;
3128                 /* Well, if the title starts with a whitespace character,
3129                  * try to be forgiving.  Otherwise we end up with no title. */
3130                 while (isspace(*line))
3131                         line++;
3132                 if (*line == '\0')
3133                         break;
3134                 /* FIXME: More graceful handling of titles; append "..." to
3135                  * shortened titles, etc. */
3136
3137                 string_copy(commit->title, line);
3138         }
3139
3140         return TRUE;
3141 }
3142
3143 static bool
3144 main_enter(struct view *view, struct line *line)
3145 {
3146         enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
3147
3148         open_view(view, REQ_VIEW_DIFF, flags);
3149         return TRUE;
3150 }
3151
3152 static bool
3153 main_grep(struct view *view, struct line *line)
3154 {
3155         struct commit *commit = line->data;
3156         enum { S_TITLE, S_AUTHOR, S_DATE, S_END } state;
3157         char buf[DATE_COLS + 1];
3158         regmatch_t pmatch;
3159
3160         for (state = S_TITLE; state < S_END; state++) {
3161                 char *text;
3162
3163                 switch (state) {
3164                 case S_TITLE:   text = commit->title;   break;
3165                 case S_AUTHOR:  text = commit->author;  break;
3166                 case S_DATE:
3167                         if (!strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time))
3168                                 continue;
3169                         text = buf;
3170                         break;
3171
3172                 default:
3173                         return FALSE;
3174                 }
3175
3176                 if (regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
3177                         return TRUE;
3178         }
3179
3180         return FALSE;
3181 }
3182
3183 static void
3184 main_select(struct view *view, struct line *line)
3185 {
3186         struct commit *commit = line->data;
3187
3188         string_copy(view->ref, commit->id);
3189         string_copy(ref_commit, view->ref);
3190 }
3191
3192 static struct view_ops main_ops = {
3193         "commit",
3194         main_draw,
3195         main_read,
3196         main_enter,
3197         main_grep,
3198         main_select,
3199 };
3200
3201
3202 /*
3203  * Unicode / UTF-8 handling
3204  *
3205  * NOTE: Much of the following code for dealing with unicode is derived from
3206  * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
3207  * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
3208  */
3209
3210 /* I've (over)annotated a lot of code snippets because I am not entirely
3211  * confident that the approach taken by this small UTF-8 interface is correct.
3212  * --jonas */
3213
3214 static inline int
3215 unicode_width(unsigned long c)
3216 {
3217         if (c >= 0x1100 &&
3218            (c <= 0x115f                         /* Hangul Jamo */
3219             || c == 0x2329
3220             || c == 0x232a
3221             || (c >= 0x2e80  && c <= 0xa4cf && c != 0x303f)
3222                                                 /* CJK ... Yi */
3223             || (c >= 0xac00  && c <= 0xd7a3)    /* Hangul Syllables */
3224             || (c >= 0xf900  && c <= 0xfaff)    /* CJK Compatibility Ideographs */
3225             || (c >= 0xfe30  && c <= 0xfe6f)    /* CJK Compatibility Forms */
3226             || (c >= 0xff00  && c <= 0xff60)    /* Fullwidth Forms */
3227             || (c >= 0xffe0  && c <= 0xffe6)
3228             || (c >= 0x20000 && c <= 0x2fffd)
3229             || (c >= 0x30000 && c <= 0x3fffd)))
3230                 return 2;
3231
3232         return 1;
3233 }
3234
3235 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
3236  * Illegal bytes are set one. */
3237 static const unsigned char utf8_bytes[256] = {
3238         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,
3239         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,
3240         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,
3241         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,
3242         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,
3243         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,
3244         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,
3245         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,
3246 };
3247
3248 /* Decode UTF-8 multi-byte representation into a unicode character. */
3249 static inline unsigned long
3250 utf8_to_unicode(const char *string, size_t length)
3251 {
3252         unsigned long unicode;
3253
3254         switch (length) {
3255         case 1:
3256                 unicode  =   string[0];
3257                 break;
3258         case 2:
3259                 unicode  =  (string[0] & 0x1f) << 6;
3260                 unicode +=  (string[1] & 0x3f);
3261                 break;
3262         case 3:
3263                 unicode  =  (string[0] & 0x0f) << 12;
3264                 unicode += ((string[1] & 0x3f) << 6);
3265                 unicode +=  (string[2] & 0x3f);
3266                 break;
3267         case 4:
3268                 unicode  =  (string[0] & 0x0f) << 18;
3269                 unicode += ((string[1] & 0x3f) << 12);
3270                 unicode += ((string[2] & 0x3f) << 6);
3271                 unicode +=  (string[3] & 0x3f);
3272                 break;
3273         case 5:
3274                 unicode  =  (string[0] & 0x0f) << 24;
3275                 unicode += ((string[1] & 0x3f) << 18);
3276                 unicode += ((string[2] & 0x3f) << 12);
3277                 unicode += ((string[3] & 0x3f) << 6);
3278                 unicode +=  (string[4] & 0x3f);
3279                 break;
3280         case 6:
3281                 unicode  =  (string[0] & 0x01) << 30;
3282                 unicode += ((string[1] & 0x3f) << 24);
3283                 unicode += ((string[2] & 0x3f) << 18);
3284                 unicode += ((string[3] & 0x3f) << 12);
3285                 unicode += ((string[4] & 0x3f) << 6);
3286                 unicode +=  (string[5] & 0x3f);
3287                 break;
3288         default:
3289                 die("Invalid unicode length");
3290         }
3291
3292         /* Invalid characters could return the special 0xfffd value but NUL
3293          * should be just as good. */
3294         return unicode > 0xffff ? 0 : unicode;
3295 }
3296
3297 /* Calculates how much of string can be shown within the given maximum width
3298  * and sets trimmed parameter to non-zero value if all of string could not be
3299  * shown.
3300  *
3301  * Additionally, adds to coloffset how many many columns to move to align with
3302  * the expected position. Takes into account how multi-byte and double-width
3303  * characters will effect the cursor position.
3304  *
3305  * Returns the number of bytes to output from string to satisfy max_width. */
3306 static size_t
3307 utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed)
3308 {
3309         const char *start = string;
3310         const char *end = strchr(string, '\0');
3311         size_t mbwidth = 0;
3312         size_t width = 0;
3313
3314         *trimmed = 0;
3315
3316         while (string < end) {
3317                 int c = *(unsigned char *) string;
3318                 unsigned char bytes = utf8_bytes[c];
3319                 size_t ucwidth;
3320                 unsigned long unicode;
3321
3322                 if (string + bytes > end)
3323                         break;
3324
3325                 /* Change representation to figure out whether
3326                  * it is a single- or double-width character. */
3327
3328                 unicode = utf8_to_unicode(string, bytes);
3329                 /* FIXME: Graceful handling of invalid unicode character. */
3330                 if (!unicode)
3331                         break;
3332
3333                 ucwidth = unicode_width(unicode);
3334                 width  += ucwidth;
3335                 if (width > max_width) {
3336                         *trimmed = 1;
3337                         break;
3338                 }
3339
3340                 /* The column offset collects the differences between the
3341                  * number of bytes encoding a character and the number of
3342                  * columns will be used for rendering said character.
3343                  *
3344                  * So if some character A is encoded in 2 bytes, but will be
3345                  * represented on the screen using only 1 byte this will and up
3346                  * adding 1 to the multi-byte column offset.
3347                  *
3348                  * Assumes that no double-width character can be encoding in
3349                  * less than two bytes. */
3350                 if (bytes > ucwidth)
3351                         mbwidth += bytes - ucwidth;
3352
3353                 string  += bytes;
3354         }
3355
3356         *coloffset += mbwidth;
3357
3358         return string - start;
3359 }
3360
3361
3362 /*
3363  * Status management
3364  */
3365
3366 /* Whether or not the curses interface has been initialized. */
3367 static bool cursed = FALSE;
3368
3369 /* The status window is used for polling keystrokes. */
3370 static WINDOW *status_win;
3371
3372 static bool status_empty = TRUE;
3373
3374 /* Update status and title window. */
3375 static void
3376 report(const char *msg, ...)
3377 {
3378         struct view *view = display[current_view];
3379
3380         if (input_mode)
3381                 return;
3382
3383         if (!status_empty || *msg) {
3384                 va_list args;
3385
3386                 va_start(args, msg);
3387
3388                 wmove(status_win, 0, 0);
3389                 if (*msg) {
3390                         vwprintw(status_win, msg, args);
3391                         status_empty = FALSE;
3392                 } else {
3393                         status_empty = TRUE;
3394                 }
3395                 wclrtoeol(status_win);
3396                 wrefresh(status_win);
3397
3398                 va_end(args);
3399         }
3400
3401         update_view_title(view);
3402         update_display_cursor(view);
3403 }
3404
3405 /* Controls when nodelay should be in effect when polling user input. */
3406 static void
3407 set_nonblocking_input(bool loading)
3408 {
3409         static unsigned int loading_views;
3410
3411         if ((loading == FALSE && loading_views-- == 1) ||
3412             (loading == TRUE  && loading_views++ == 0))
3413                 nodelay(status_win, loading);
3414 }
3415
3416 static void
3417 init_display(void)
3418 {
3419         int x, y;
3420
3421         /* Initialize the curses library */
3422         if (isatty(STDIN_FILENO)) {
3423                 cursed = !!initscr();
3424         } else {
3425                 /* Leave stdin and stdout alone when acting as a pager. */
3426                 FILE *io = fopen("/dev/tty", "r+");
3427
3428                 if (!io)
3429                         die("Failed to open /dev/tty");
3430                 cursed = !!newterm(NULL, io, io);
3431         }
3432
3433         if (!cursed)
3434                 die("Failed to initialize curses");
3435
3436         nonl();         /* Tell curses not to do NL->CR/NL on output */
3437         cbreak();       /* Take input chars one at a time, no wait for \n */
3438         noecho();       /* Don't echo input */
3439         leaveok(stdscr, TRUE);
3440
3441         if (has_colors())
3442                 init_colors();
3443
3444         getmaxyx(stdscr, y, x);
3445         status_win = newwin(1, 0, y - 1, 0);
3446         if (!status_win)
3447                 die("Failed to create status window");
3448
3449         /* Enable keyboard mapping */
3450         keypad(status_win, TRUE);
3451         wbkgdset(status_win, get_line_attr(LINE_STATUS));
3452 }
3453
3454 static char *
3455 read_prompt(const char *prompt)
3456 {
3457         enum { READING, STOP, CANCEL } status = READING;
3458         static char buf[sizeof(opt_cmd) - STRING_SIZE("git \0")];
3459         int pos = 0;
3460
3461         while (status == READING) {
3462                 struct view *view;
3463                 int i, key;
3464
3465                 input_mode = TRUE;
3466
3467                 foreach_view (view, i)
3468                         update_view(view);
3469
3470                 input_mode = FALSE;
3471
3472                 mvwprintw(status_win, 0, 0, "%s%.*s", prompt, pos, buf);
3473                 wclrtoeol(status_win);
3474
3475                 /* Refresh, accept single keystroke of input */
3476                 key = wgetch(status_win);
3477                 switch (key) {
3478                 case KEY_RETURN:
3479                 case KEY_ENTER:
3480                 case '\n':
3481                         status = pos ? STOP : CANCEL;
3482                         break;
3483
3484                 case KEY_BACKSPACE:
3485                         if (pos > 0)
3486                                 pos--;
3487                         else
3488                                 status = CANCEL;
3489                         break;
3490
3491                 case KEY_ESC:
3492                         status = CANCEL;
3493                         break;
3494
3495                 case ERR:
3496                         break;
3497
3498                 default:
3499                         if (pos >= sizeof(buf)) {
3500                                 report("Input string too long");
3501                                 return NULL;
3502                         }
3503
3504                         if (isprint(key))
3505                                 buf[pos++] = (char) key;
3506                 }
3507         }
3508
3509         /* Clear the status window */
3510         status_empty = FALSE;
3511         report("");
3512
3513         if (status == CANCEL)
3514                 return NULL;
3515
3516         buf[pos++] = 0;
3517
3518         return buf;
3519 }
3520
3521 /*
3522  * Repository references
3523  */
3524
3525 static struct ref *refs;
3526 static size_t refs_size;
3527
3528 /* Id <-> ref store */
3529 static struct ref ***id_refs;
3530 static size_t id_refs_size;
3531
3532 static struct ref **
3533 get_refs(char *id)
3534 {
3535         struct ref ***tmp_id_refs;
3536         struct ref **ref_list = NULL;
3537         size_t ref_list_size = 0;
3538         size_t i;
3539
3540         for (i = 0; i < id_refs_size; i++)
3541                 if (!strcmp(id, id_refs[i][0]->id))
3542                         return id_refs[i];
3543
3544         tmp_id_refs = realloc(id_refs, (id_refs_size + 1) * sizeof(*id_refs));
3545         if (!tmp_id_refs)
3546                 return NULL;
3547
3548         id_refs = tmp_id_refs;
3549
3550         for (i = 0; i < refs_size; i++) {
3551                 struct ref **tmp;
3552
3553                 if (strcmp(id, refs[i].id))
3554                         continue;
3555
3556                 tmp = realloc(ref_list, (ref_list_size + 1) * sizeof(*ref_list));
3557                 if (!tmp) {
3558                         if (ref_list)
3559                                 free(ref_list);
3560                         return NULL;
3561                 }
3562
3563                 ref_list = tmp;
3564                 if (ref_list_size > 0)
3565                         ref_list[ref_list_size - 1]->next = 1;
3566                 ref_list[ref_list_size] = &refs[i];
3567
3568                 /* XXX: The properties of the commit chains ensures that we can
3569                  * safely modify the shared ref. The repo references will
3570                  * always be similar for the same id. */
3571                 ref_list[ref_list_size]->next = 0;
3572                 ref_list_size++;
3573         }
3574
3575         if (ref_list)
3576                 id_refs[id_refs_size++] = ref_list;
3577
3578         return ref_list;
3579 }
3580
3581 static int
3582 read_ref(char *id, int idlen, char *name, int namelen)
3583 {
3584         struct ref *ref;
3585         bool tag = FALSE;
3586         bool remote = FALSE;
3587
3588         if (!strncmp(name, "refs/tags/", STRING_SIZE("refs/tags/"))) {
3589                 /* Commits referenced by tags has "^{}" appended. */
3590                 if (name[namelen - 1] != '}')
3591                         return OK;
3592
3593                 while (namelen > 0 && name[namelen] != '^')
3594                         namelen--;
3595
3596                 tag = TRUE;
3597                 namelen -= STRING_SIZE("refs/tags/");
3598                 name    += STRING_SIZE("refs/tags/");
3599
3600         } else if (!strncmp(name, "refs/remotes/", STRING_SIZE("refs/remotes/"))) {
3601                 remote = TRUE;
3602                 namelen -= STRING_SIZE("refs/remotes/");
3603                 name    += STRING_SIZE("refs/remotes/");
3604
3605         } else if (!strncmp(name, "refs/heads/", STRING_SIZE("refs/heads/"))) {
3606                 namelen -= STRING_SIZE("refs/heads/");
3607                 name    += STRING_SIZE("refs/heads/");
3608
3609         } else if (!strcmp(name, "HEAD")) {
3610                 return OK;
3611         }
3612
3613         refs = realloc(refs, sizeof(*refs) * (refs_size + 1));
3614         if (!refs)
3615                 return ERR;
3616
3617         ref = &refs[refs_size++];
3618         ref->name = malloc(namelen + 1);
3619         if (!ref->name)
3620                 return ERR;
3621
3622         strncpy(ref->name, name, namelen);
3623         ref->name[namelen] = 0;
3624         ref->tag = tag;
3625         ref->remote = remote;
3626         string_copy(ref->id, id);
3627
3628         return OK;
3629 }
3630
3631 static int
3632 load_refs(void)
3633 {
3634         const char *cmd_env = getenv("TIG_LS_REMOTE");
3635         const char *cmd = cmd_env && *cmd_env ? cmd_env : TIG_LS_REMOTE;
3636
3637         return read_properties(popen(cmd, "r"), "\t", read_ref);
3638 }
3639
3640 static int
3641 read_repo_config_option(char *name, int namelen, char *value, int valuelen)
3642 {
3643         if (!strcmp(name, "i18n.commitencoding"))
3644                 string_copy(opt_encoding, value);
3645
3646         return OK;
3647 }
3648
3649 static int
3650 load_repo_config(void)
3651 {
3652         return read_properties(popen("git repo-config --list", "r"),
3653                                "=", read_repo_config_option);
3654 }
3655
3656 static int
3657 read_properties(FILE *pipe, const char *separators,
3658                 int (*read_property)(char *, int, char *, int))
3659 {
3660         char buffer[BUFSIZ];
3661         char *name;
3662         int state = OK;
3663
3664         if (!pipe)
3665                 return ERR;
3666
3667         while (state == OK && (name = fgets(buffer, sizeof(buffer), pipe))) {
3668                 char *value;
3669                 size_t namelen;
3670                 size_t valuelen;
3671
3672                 name = chomp_string(name);
3673                 namelen = strcspn(name, separators);
3674
3675                 if (name[namelen]) {
3676                         name[namelen] = 0;
3677                         value = chomp_string(name + namelen + 1);
3678                         valuelen = strlen(value);
3679
3680                 } else {
3681                         value = "";
3682                         valuelen = 0;
3683                 }
3684
3685                 state = read_property(name, namelen, value, valuelen);
3686         }
3687
3688         if (state != ERR && ferror(pipe))
3689                 state = ERR;
3690
3691         pclose(pipe);
3692
3693         return state;
3694 }
3695
3696
3697 /*
3698  * Main
3699  */
3700
3701 static void __NORETURN
3702 quit(int sig)
3703 {
3704         /* XXX: Restore tty modes and let the OS cleanup the rest! */
3705         if (cursed)
3706                 endwin();
3707         exit(0);
3708 }
3709
3710 static void __NORETURN
3711 die(const char *err, ...)
3712 {
3713         va_list args;
3714
3715         endwin();
3716
3717         va_start(args, err);
3718         fputs("tig: ", stderr);
3719         vfprintf(stderr, err, args);
3720         fputs("\n", stderr);
3721         va_end(args);
3722
3723         exit(1);
3724 }
3725
3726 int
3727 main(int argc, char *argv[])
3728 {
3729         struct view *view;
3730         enum request request;
3731         size_t i;
3732
3733         signal(SIGINT, quit);
3734
3735         if (setlocale(LC_ALL, "")) {
3736                 string_copy(opt_codeset, nl_langinfo(CODESET));
3737         }
3738
3739         if (load_options() == ERR)
3740                 die("Failed to load user config.");
3741
3742         /* Load the repo config file so options can be overwritten from
3743          * the command line.  */
3744         if (load_repo_config() == ERR)
3745                 die("Failed to load repo config.");
3746
3747         if (!parse_options(argc, argv))
3748                 return 0;
3749
3750         if (*opt_codeset && strcmp(opt_codeset, opt_encoding)) {
3751                 opt_iconv = iconv_open(opt_codeset, opt_encoding);
3752                 if (opt_iconv == ICONV_NONE)
3753                         die("Failed to initialize character set conversion");
3754         }
3755
3756         if (load_refs() == ERR)
3757                 die("Failed to load refs.");
3758
3759         /* Require a git repository unless when running in pager mode. */
3760         if (refs_size == 0 && opt_request != REQ_VIEW_PAGER)
3761                 die("Not a git repository");
3762
3763         for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
3764                 view->cmd_env = getenv(view->cmd_env);
3765
3766         request = opt_request;
3767
3768         init_display();
3769
3770         while (view_driver(display[current_view], request)) {
3771                 int key;
3772                 int i;
3773
3774                 foreach_view (view, i)
3775                         update_view(view);
3776
3777                 /* Refresh, accept single keystroke of input */
3778                 key = wgetch(status_win);
3779
3780                 /* wgetch() with nodelay() enabled returns ERR when there's no
3781                  * input. */
3782                 if (key == ERR) {
3783                         request = REQ_NONE;
3784                         continue;
3785                 }
3786
3787                 request = get_keybinding(display[current_view]->keymap, key);
3788
3789                 /* Some low-level request handling. This keeps access to
3790                  * status_win restricted. */
3791                 switch (request) {
3792                 case REQ_PROMPT:
3793                 {
3794                         char *cmd = read_prompt(":");
3795
3796                         if (cmd && string_format(opt_cmd, "git %s", cmd)) {
3797                                 if (strncmp(cmd, "show", 4) && isspace(cmd[4])) {
3798                                         opt_request = REQ_VIEW_DIFF;
3799                                 } else {
3800                                         opt_request = REQ_VIEW_PAGER;
3801                                 }
3802                                 break;
3803                         }
3804
3805                         request = REQ_NONE;
3806                         break;
3807                 }
3808                 case REQ_SEARCH:
3809                 case REQ_SEARCH_BACK:
3810                 {
3811                         const char *prompt = request == REQ_SEARCH
3812                                            ? "/" : "?";
3813                         char *search = read_prompt(prompt);
3814
3815                         if (search)
3816                                 string_copy(opt_search, search);
3817                         else
3818                                 request = REQ_NONE;
3819                         break;
3820                 }
3821                 case REQ_SCREEN_RESIZE:
3822                 {
3823                         int height, width;
3824
3825                         getmaxyx(stdscr, height, width);
3826
3827                         /* Resize the status view and let the view driver take
3828                          * care of resizing the displayed views. */
3829                         wresize(status_win, 1, width);
3830                         mvwin(status_win, height - 1, 0);
3831                         wrefresh(status_win);
3832                         break;
3833                 }
3834                 default:
3835                         break;
3836                 }
3837         }
3838
3839         quit(0);
3840
3841         return 0;
3842 }