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

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