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