git.oblomov.eu Git - tig/blob - tig.c

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