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

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