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

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