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