chiark - git - mdw - tig/blob - tig.c

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