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