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

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