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