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

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