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