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         return TRUE;
3143 }
3144
3145 static void
3146 status_update(struct view *view)
3147 {
3148         if (view == VIEW(REQ_VIEW_STATUS)) {
3149                 struct line *line = &view->line[view->lineno];
3150
3151                 assert(view->lines);
3152
3153                 if (!line->data) {
3154                         if (line[1].type == LINE_STAT_NONE) {
3155                                 report("Nothing to update");
3156                                 return;
3157                         }
3158
3159                         while (++line < view->line + view->lines && line->data) {
3160                                 if (!status_update_file(view, line->data, line->type))
3161                                         report("Failed to update file status");
3162                         }
3163
3164                 } else if (!status_update_file(view, line->data, line->type)) {
3165                         report("Failed to update file status");
3166                 }
3167
3168                 open_view(view, REQ_VIEW_STATUS, OPEN_RELOAD);
3169         } else {
3170                 report("This action is only valid for the status view");
3171         }
3172 }
3173
3174 static void
3175 status_select(struct view *view, struct line *line)
3176 {
3177         char *text;
3178
3179         switch (line->type) {
3180         case LINE_STAT_STAGED:
3181                 text = "Press %s to unstage file for commit";
3182                 break;
3183
3184         case LINE_STAT_UNSTAGED:
3185                 text = "Press %s to stage file for commit  ";
3186                 break;
3187
3188         case LINE_STAT_UNTRACKED:
3189                 text = "Press %s to stage file for addition";
3190                 break;
3191
3192         case LINE_STAT_NONE:
3193                 return;
3194
3195         default:
3196                 die("w00t");
3197         }
3198
3199         string_format(view->ref, text, get_key(REQ_STATUS_UPDATE));
3200 }
3201
3202 static bool
3203 status_grep(struct view *view, struct line *line)
3204 {
3205         struct status *status = line->data;
3206         enum { S_STATUS, S_NAME, S_END } state;
3207         char buf[2] = "?";
3208         regmatch_t pmatch;
3209
3210         if (!status)
3211                 return FALSE;
3212
3213         for (state = S_STATUS; state < S_END; state++) {
3214                 char *text;
3215
3216                 switch (state) {
3217                 case S_NAME:    text = status->name;    break;
3218                 case S_STATUS:
3219                         buf[0] = status->status;
3220                         text = buf;
3221                         break;
3222
3223                 default:
3224                         return FALSE;
3225                 }
3226
3227                 if (regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
3228                         return TRUE;
3229         }
3230
3231         return FALSE;
3232 }
3233
3234 static struct view_ops status_ops = {
3235         "file",
3236         status_open,
3237         NULL,
3238         status_draw,
3239         status_enter,
3240         status_grep,
3241         status_select,
3242 };
3243
3244
3245 /*
3246  * Revision graph
3247  */
3248
3249 struct commit {
3250         char id[SIZEOF_REV];            /* SHA1 ID. */
3251         char title[128];                /* First line of the commit message. */
3252         char author[75];                /* Author of the commit. */
3253         struct tm time;                 /* Date from the author ident. */
3254         struct ref **refs;              /* Repository references. */
3255         chtype graph[SIZEOF_REVGRAPH];  /* Ancestry chain graphics. */
3256         size_t graph_size;              /* The width of the graph array. */
3257 };
3258
3259 /* Size of rev graph with no  "padding" columns */
3260 #define SIZEOF_REVITEMS (SIZEOF_REVGRAPH - (SIZEOF_REVGRAPH / 2))
3261
3262 struct rev_graph {
3263         struct rev_graph *prev, *next, *parents;
3264         char rev[SIZEOF_REVITEMS][SIZEOF_REV];
3265         size_t size;
3266         struct commit *commit;
3267         size_t pos;
3268 };
3269
3270 /* Parents of the commit being visualized. */
3271 static struct rev_graph graph_parents[4];
3272
3273 /* The current stack of revisions on the graph. */
3274 static struct rev_graph graph_stacks[4] = {
3275         { &graph_stacks[3], &graph_stacks[1], &graph_parents[0] },
3276         { &graph_stacks[0], &graph_stacks[2], &graph_parents[1] },
3277         { &graph_stacks[1], &graph_stacks[3], &graph_parents[2] },
3278         { &graph_stacks[2], &graph_stacks[0], &graph_parents[3] },
3279 };
3280
3281 static inline bool
3282 graph_parent_is_merge(struct rev_graph *graph)
3283 {
3284         return graph->parents->size > 1;
3285 }
3286
3287 static inline void
3288 append_to_rev_graph(struct rev_graph *graph, chtype symbol)
3289 {
3290         struct commit *commit = graph->commit;
3291
3292         if (commit->graph_size < ARRAY_SIZE(commit->graph) - 1)
3293                 commit->graph[commit->graph_size++] = symbol;
3294 }
3295
3296 static void
3297 done_rev_graph(struct rev_graph *graph)
3298 {
3299         if (graph_parent_is_merge(graph) &&
3300             graph->pos < graph->size - 1 &&
3301             graph->next->size == graph->size + graph->parents->size - 1) {
3302                 size_t i = graph->pos + graph->parents->size - 1;
3303
3304                 graph->commit->graph_size = i * 2;
3305                 while (i < graph->next->size - 1) {
3306                         append_to_rev_graph(graph, ' ');
3307                         append_to_rev_graph(graph, '\\');
3308                         i++;
3309                 }
3310         }
3311
3312         graph->size = graph->pos = 0;
3313         graph->commit = NULL;
3314         memset(graph->parents, 0, sizeof(*graph->parents));
3315 }
3316
3317 static void
3318 push_rev_graph(struct rev_graph *graph, char *parent)
3319 {
3320         int i;
3321
3322         /* "Collapse" duplicate parents lines.
3323          *
3324          * FIXME: This needs to also update update the drawn graph but
3325          * for now it just serves as a method for pruning graph lines. */
3326         for (i = 0; i < graph->size; i++)
3327                 if (!strncmp(graph->rev[i], parent, SIZEOF_REV))
3328                         return;
3329
3330         if (graph->size < SIZEOF_REVITEMS) {
3331                 string_copy_rev(graph->rev[graph->size++], parent);
3332         }
3333 }
3334
3335 static chtype
3336 get_rev_graph_symbol(struct rev_graph *graph)
3337 {
3338         chtype symbol;
3339
3340         if (graph->parents->size == 0)
3341                 symbol = REVGRAPH_INIT;
3342         else if (graph_parent_is_merge(graph))
3343                 symbol = REVGRAPH_MERGE;
3344         else if (graph->pos >= graph->size)
3345                 symbol = REVGRAPH_BRANCH;
3346         else
3347                 symbol = REVGRAPH_COMMIT;
3348
3349         return symbol;
3350 }
3351
3352 static void
3353 draw_rev_graph(struct rev_graph *graph)
3354 {
3355         struct rev_filler {
3356                 chtype separator, line;
3357         };
3358         enum { DEFAULT, RSHARP, RDIAG, LDIAG };
3359         static struct rev_filler fillers[] = {
3360                 { ' ',  REVGRAPH_LINE },
3361                 { '`',  '.' },
3362                 { '\'', ' ' },
3363                 { '/',  ' ' },
3364         };
3365         chtype symbol = get_rev_graph_symbol(graph);
3366         struct rev_filler *filler;
3367         size_t i;
3368
3369         filler = &fillers[DEFAULT];
3370
3371         for (i = 0; i < graph->pos; i++) {
3372                 append_to_rev_graph(graph, filler->line);
3373                 if (graph_parent_is_merge(graph->prev) &&
3374                     graph->prev->pos == i)
3375                         filler = &fillers[RSHARP];
3376
3377                 append_to_rev_graph(graph, filler->separator);
3378         }
3379
3380         /* Place the symbol for this revision. */
3381         append_to_rev_graph(graph, symbol);
3382
3383         if (graph->prev->size > graph->size)
3384                 filler = &fillers[RDIAG];
3385         else
3386                 filler = &fillers[DEFAULT];
3387
3388         i++;
3389
3390         for (; i < graph->size; i++) {
3391                 append_to_rev_graph(graph, filler->separator);
3392                 append_to_rev_graph(graph, filler->line);
3393                 if (graph_parent_is_merge(graph->prev) &&
3394                     i < graph->prev->pos + graph->parents->size)
3395                         filler = &fillers[RSHARP];
3396                 if (graph->prev->size > graph->size)
3397                         filler = &fillers[LDIAG];
3398         }
3399
3400         if (graph->prev->size > graph->size) {
3401                 append_to_rev_graph(graph, filler->separator);
3402                 if (filler->line != ' ')
3403                         append_to_rev_graph(graph, filler->line);
3404         }
3405 }
3406
3407 /* Prepare the next rev graph */
3408 static void
3409 prepare_rev_graph(struct rev_graph *graph)
3410 {
3411         size_t i;
3412
3413         /* First, traverse all lines of revisions up to the active one. */
3414         for (graph->pos = 0; graph->pos < graph->size; graph->pos++) {
3415                 if (!strcmp(graph->rev[graph->pos], graph->commit->id))
3416                         break;
3417
3418                 push_rev_graph(graph->next, graph->rev[graph->pos]);
3419         }
3420
3421         /* Interleave the new revision parent(s). */
3422         for (i = 0; i < graph->parents->size; i++)
3423                 push_rev_graph(graph->next, graph->parents->rev[i]);
3424
3425         /* Lastly, put any remaining revisions. */
3426         for (i = graph->pos + 1; i < graph->size; i++)
3427                 push_rev_graph(graph->next, graph->rev[i]);
3428 }
3429
3430 static void
3431 update_rev_graph(struct rev_graph *graph)
3432 {
3433         /* If this is the finalizing update ... */
3434         if (graph->commit)
3435                 prepare_rev_graph(graph);
3436
3437         /* Graph visualization needs a one rev look-ahead,
3438          * so the first update doesn't visualize anything. */
3439         if (!graph->prev->commit)
3440                 return;
3441
3442         draw_rev_graph(graph->prev);
3443         done_rev_graph(graph->prev->prev);
3444 }
3445
3446
3447 /*
3448  * Main view backend
3449  */
3450
3451 static bool
3452 main_draw(struct view *view, struct line *line, unsigned int lineno, bool selected)
3453 {
3454         char buf[DATE_COLS + 1];
3455         struct commit *commit = line->data;
3456         enum line_type type;
3457         int col = 0;
3458         size_t timelen;
3459         size_t authorlen;
3460         int trimmed = 1;
3461
3462         if (!*commit->author)
3463                 return FALSE;
3464
3465         wmove(view->win, lineno, col);
3466
3467         if (selected) {
3468                 type = LINE_CURSOR;
3469                 wattrset(view->win, get_line_attr(type));
3470                 wchgat(view->win, -1, 0, type, NULL);
3471
3472         } else {
3473                 type = LINE_MAIN_COMMIT;
3474                 wattrset(view->win, get_line_attr(LINE_MAIN_DATE));
3475         }
3476
3477         timelen = strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time);
3478         waddnstr(view->win, buf, timelen);
3479         waddstr(view->win, " ");
3480
3481         col += DATE_COLS;
3482         wmove(view->win, lineno, col);
3483         if (type != LINE_CURSOR)
3484                 wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
3485
3486         if (opt_utf8) {
3487                 authorlen = utf8_length(commit->author, AUTHOR_COLS - 2, &col, &trimmed);
3488         } else {
3489                 authorlen = strlen(commit->author);
3490                 if (authorlen > AUTHOR_COLS - 2) {
3491                         authorlen = AUTHOR_COLS - 2;
3492                         trimmed = 1;
3493                 }
3494         }
3495
3496         if (trimmed) {
3497                 waddnstr(view->win, commit->author, authorlen);
3498                 if (type != LINE_CURSOR)
3499                         wattrset(view->win, get_line_attr(LINE_MAIN_DELIM));
3500                 waddch(view->win, '~');
3501         } else {
3502                 waddstr(view->win, commit->author);
3503         }
3504
3505         col += AUTHOR_COLS;
3506         if (type != LINE_CURSOR)
3507                 wattrset(view->win, A_NORMAL);
3508
3509         if (opt_rev_graph && commit->graph_size) {
3510                 size_t i;
3511
3512                 wmove(view->win, lineno, col);
3513                 /* Using waddch() instead of waddnstr() ensures that
3514                  * they'll be rendered correctly for the cursor line. */
3515                 for (i = 0; i < commit->graph_size; i++)
3516                         waddch(view->win, commit->graph[i]);
3517
3518                 waddch(view->win, ' ');
3519                 col += commit->graph_size + 1;
3520         }
3521
3522         wmove(view->win, lineno, col);
3523
3524         if (commit->refs) {
3525                 size_t i = 0;
3526
3527                 do {
3528                         if (type == LINE_CURSOR)
3529                                 ;
3530                         else if (commit->refs[i]->tag)
3531                                 wattrset(view->win, get_line_attr(LINE_MAIN_TAG));
3532                         else if (commit->refs[i]->remote)
3533                                 wattrset(view->win, get_line_attr(LINE_MAIN_REMOTE));
3534                         else
3535                                 wattrset(view->win, get_line_attr(LINE_MAIN_REF));
3536                         waddstr(view->win, "[");
3537                         waddstr(view->win, commit->refs[i]->name);
3538                         waddstr(view->win, "]");
3539                         if (type != LINE_CURSOR)
3540                                 wattrset(view->win, A_NORMAL);
3541                         waddstr(view->win, " ");
3542                         col += strlen(commit->refs[i]->name) + STRING_SIZE("[] ");
3543                 } while (commit->refs[i++]->next);
3544         }
3545
3546         if (type != LINE_CURSOR)
3547                 wattrset(view->win, get_line_attr(type));
3548
3549         {
3550                 int titlelen = strlen(commit->title);
3551
3552                 if (col + titlelen > view->width)
3553                         titlelen = view->width - col;
3554
3555                 waddnstr(view->win, commit->title, titlelen);
3556         }
3557
3558         return TRUE;
3559 }
3560
3561 /* Reads git log --pretty=raw output and parses it into the commit struct. */
3562 static bool
3563 main_read(struct view *view, char *line)
3564 {
3565         static struct rev_graph *graph = graph_stacks;
3566         enum line_type type;
3567         struct commit *commit;
3568
3569         if (!line) {
3570                 update_rev_graph(graph);
3571                 return TRUE;
3572         }
3573
3574         type = get_line_type(line);
3575         if (type == LINE_COMMIT) {
3576                 commit = calloc(1, sizeof(struct commit));
3577                 if (!commit)
3578                         return FALSE;
3579
3580                 string_copy_rev(commit->id, line + STRING_SIZE("commit "));
3581                 commit->refs = get_refs(commit->id);
3582                 graph->commit = commit;
3583                 add_line_data(view, commit, LINE_MAIN_COMMIT);
3584                 return TRUE;
3585         }
3586
3587         if (!view->lines)
3588                 return TRUE;
3589         commit = view->line[view->lines - 1].data;
3590
3591         switch (type) {
3592         case LINE_PARENT:
3593                 push_rev_graph(graph->parents, line + STRING_SIZE("parent "));
3594                 break;
3595
3596         case LINE_AUTHOR:
3597         {
3598                 /* Parse author lines where the name may be empty:
3599                  *      author  <email@address.tld> 1138474660 +0100
3600                  */
3601                 char *ident = line + STRING_SIZE("author ");
3602                 char *nameend = strchr(ident, '<');
3603                 char *emailend = strchr(ident, '>');
3604
3605                 if (!nameend || !emailend)
3606                         break;
3607
3608                 update_rev_graph(graph);
3609                 graph = graph->next;
3610
3611                 *nameend = *emailend = 0;
3612                 ident = chomp_string(ident);
3613                 if (!*ident) {
3614                         ident = chomp_string(nameend + 1);
3615                         if (!*ident)
3616                                 ident = "Unknown";
3617                 }
3618
3619                 string_ncopy(commit->author, ident, strlen(ident));
3620
3621                 /* Parse epoch and timezone */
3622                 if (emailend[1] == ' ') {
3623                         char *secs = emailend + 2;
3624                         char *zone = strchr(secs, ' ');
3625                         time_t time = (time_t) atol(secs);
3626
3627                         if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
3628                                 long tz;
3629
3630                                 zone++;
3631                                 tz  = ('0' - zone[1]) * 60 * 60 * 10;
3632                                 tz += ('0' - zone[2]) * 60 * 60;
3633                                 tz += ('0' - zone[3]) * 60;
3634                                 tz += ('0' - zone[4]) * 60;
3635
3636                                 if (zone[0] == '-')
3637                                         tz = -tz;
3638
3639                                 time -= tz;
3640                         }
3641
3642                         gmtime_r(&time, &commit->time);
3643                 }
3644                 break;
3645         }
3646         default:
3647                 /* Fill in the commit title if it has not already been set. */
3648                 if (commit->title[0])
3649                         break;
3650
3651                 /* Require titles to start with a non-space character at the
3652                  * offset used by git log. */
3653                 if (strncmp(line, "    ", 4))
3654                         break;
3655                 line += 4;
3656                 /* Well, if the title starts with a whitespace character,
3657                  * try to be forgiving.  Otherwise we end up with no title. */
3658                 while (isspace(*line))
3659                         line++;
3660                 if (*line == '\0')
3661                         break;
3662                 /* FIXME: More graceful handling of titles; append "..." to
3663                  * shortened titles, etc. */
3664
3665                 string_ncopy(commit->title, line, strlen(line));
3666         }
3667
3668         return TRUE;
3669 }
3670
3671 static bool
3672 main_enter(struct view *view, struct line *line)
3673 {
3674         enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
3675
3676         open_view(view, REQ_VIEW_DIFF, flags);
3677         return TRUE;
3678 }
3679
3680 static bool
3681 main_grep(struct view *view, struct line *line)
3682 {
3683         struct commit *commit = line->data;
3684         enum { S_TITLE, S_AUTHOR, S_DATE, S_END } state;
3685         char buf[DATE_COLS + 1];
3686         regmatch_t pmatch;
3687
3688         for (state = S_TITLE; state < S_END; state++) {
3689                 char *text;
3690
3691                 switch (state) {
3692                 case S_TITLE:   text = commit->title;   break;
3693                 case S_AUTHOR:  text = commit->author;  break;
3694                 case S_DATE:
3695                         if (!strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time))
3696                                 continue;
3697                         text = buf;
3698                         break;
3699
3700                 default:
3701                         return FALSE;
3702                 }
3703
3704                 if (regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
3705                         return TRUE;
3706         }
3707
3708         return FALSE;
3709 }
3710
3711 static void
3712 main_select(struct view *view, struct line *line)
3713 {
3714         struct commit *commit = line->data;
3715
3716         string_copy_rev(view->ref, commit->id);
3717         string_copy_rev(ref_commit, view->ref);
3718 }
3719
3720 static struct view_ops main_ops = {
3721         "commit",
3722         NULL,
3723         main_read,
3724         main_draw,
3725         main_enter,
3726         main_grep,
3727         main_select,
3728 };
3729
3730
3731 /*
3732  * Unicode / UTF-8 handling
3733  *
3734  * NOTE: Much of the following code for dealing with unicode is derived from
3735  * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
3736  * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
3737  */
3738
3739 /* I've (over)annotated a lot of code snippets because I am not entirely
3740  * confident that the approach taken by this small UTF-8 interface is correct.
3741  * --jonas */
3742
3743 static inline int
3744 unicode_width(unsigned long c)
3745 {
3746         if (c >= 0x1100 &&
3747            (c <= 0x115f                         /* Hangul Jamo */
3748             || c == 0x2329
3749             || c == 0x232a
3750             || (c >= 0x2e80  && c <= 0xa4cf && c != 0x303f)
3751                                                 /* CJK ... Yi */
3752             || (c >= 0xac00  && c <= 0xd7a3)    /* Hangul Syllables */
3753             || (c >= 0xf900  && c <= 0xfaff)    /* CJK Compatibility Ideographs */
3754             || (c >= 0xfe30  && c <= 0xfe6f)    /* CJK Compatibility Forms */
3755             || (c >= 0xff00  && c <= 0xff60)    /* Fullwidth Forms */
3756             || (c >= 0xffe0  && c <= 0xffe6)
3757             || (c >= 0x20000 && c <= 0x2fffd)
3758             || (c >= 0x30000 && c <= 0x3fffd)))
3759                 return 2;
3760
3761         return 1;
3762 }
3763
3764 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
3765  * Illegal bytes are set one. */
3766 static const unsigned char utf8_bytes[256] = {
3767         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,
3768         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,
3769         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,
3770         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,
3771         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,
3772         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,
3773         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,
3774         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,
3775 };
3776
3777 /* Decode UTF-8 multi-byte representation into a unicode character. */
3778 static inline unsigned long
3779 utf8_to_unicode(const char *string, size_t length)
3780 {
3781         unsigned long unicode;
3782
3783         switch (length) {
3784         case 1:
3785                 unicode  =   string[0];
3786                 break;
3787         case 2:
3788                 unicode  =  (string[0] & 0x1f) << 6;
3789                 unicode +=  (string[1] & 0x3f);
3790                 break;
3791         case 3:
3792                 unicode  =  (string[0] & 0x0f) << 12;
3793                 unicode += ((string[1] & 0x3f) << 6);
3794                 unicode +=  (string[2] & 0x3f);
3795                 break;
3796         case 4:
3797                 unicode  =  (string[0] & 0x0f) << 18;
3798                 unicode += ((string[1] & 0x3f) << 12);
3799                 unicode += ((string[2] & 0x3f) << 6);
3800                 unicode +=  (string[3] & 0x3f);
3801                 break;
3802         case 5:
3803                 unicode  =  (string[0] & 0x0f) << 24;
3804                 unicode += ((string[1] & 0x3f) << 18);
3805                 unicode += ((string[2] & 0x3f) << 12);
3806                 unicode += ((string[3] & 0x3f) << 6);
3807                 unicode +=  (string[4] & 0x3f);
3808                 break;
3809         case 6:
3810                 unicode  =  (string[0] & 0x01) << 30;
3811                 unicode += ((string[1] & 0x3f) << 24);
3812                 unicode += ((string[2] & 0x3f) << 18);
3813                 unicode += ((string[3] & 0x3f) << 12);
3814                 unicode += ((string[4] & 0x3f) << 6);
3815                 unicode +=  (string[5] & 0x3f);
3816                 break;
3817         default:
3818                 die("Invalid unicode length");
3819         }
3820
3821         /* Invalid characters could return the special 0xfffd value but NUL
3822          * should be just as good. */
3823         return unicode > 0xffff ? 0 : unicode;
3824 }
3825
3826 /* Calculates how much of string can be shown within the given maximum width
3827  * and sets trimmed parameter to non-zero value if all of string could not be
3828  * shown.
3829  *
3830  * Additionally, adds to coloffset how many many columns to move to align with
3831  * the expected position. Takes into account how multi-byte and double-width
3832  * characters will effect the cursor position.
3833  *
3834  * Returns the number of bytes to output from string to satisfy max_width. */
3835 static size_t
3836 utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed)
3837 {
3838         const char *start = string;
3839         const char *end = strchr(string, '\0');
3840         size_t mbwidth = 0;
3841         size_t width = 0;
3842
3843         *trimmed = 0;
3844
3845         while (string < end) {
3846                 int c = *(unsigned char *) string;
3847                 unsigned char bytes = utf8_bytes[c];
3848                 size_t ucwidth;
3849                 unsigned long unicode;
3850
3851                 if (string + bytes > end)
3852                         break;
3853
3854                 /* Change representation to figure out whether
3855                  * it is a single- or double-width character. */
3856
3857                 unicode = utf8_to_unicode(string, bytes);
3858                 /* FIXME: Graceful handling of invalid unicode character. */
3859                 if (!unicode)
3860                         break;
3861
3862                 ucwidth = unicode_width(unicode);
3863                 width  += ucwidth;
3864                 if (width > max_width) {
3865                         *trimmed = 1;
3866                         break;
3867                 }
3868
3869                 /* The column offset collects the differences between the
3870                  * number of bytes encoding a character and the number of
3871                  * columns will be used for rendering said character.
3872                  *
3873                  * So if some character A is encoded in 2 bytes, but will be
3874                  * represented on the screen using only 1 byte this will and up
3875                  * adding 1 to the multi-byte column offset.
3876                  *
3877                  * Assumes that no double-width character can be encoding in
3878                  * less than two bytes. */
3879                 if (bytes > ucwidth)
3880                         mbwidth += bytes - ucwidth;
3881
3882                 string  += bytes;
3883         }
3884
3885         *coloffset += mbwidth;
3886
3887         return string - start;
3888 }
3889
3890
3891 /*
3892  * Status management
3893  */
3894
3895 /* Whether or not the curses interface has been initialized. */
3896 static bool cursed = FALSE;
3897
3898 /* The status window is used for polling keystrokes. */
3899 static WINDOW *status_win;
3900
3901 static bool status_empty = TRUE;
3902
3903 /* Update status and title window. */
3904 static void
3905 report(const char *msg, ...)
3906 {
3907         struct view *view = display[current_view];
3908
3909         if (input_mode)
3910                 return;
3911
3912         if (!status_empty || *msg) {
3913                 va_list args;
3914
3915                 va_start(args, msg);
3916
3917                 wmove(status_win, 0, 0);
3918                 if (*msg) {
3919                         vwprintw(status_win, msg, args);
3920                         status_empty = FALSE;
3921                 } else {
3922                         status_empty = TRUE;
3923                 }
3924                 wclrtoeol(status_win);
3925                 wrefresh(status_win);
3926
3927                 va_end(args);
3928         }
3929
3930         update_view_title(view);
3931         update_display_cursor(view);
3932 }
3933
3934 /* Controls when nodelay should be in effect when polling user input. */
3935 static void
3936 set_nonblocking_input(bool loading)
3937 {
3938         static unsigned int loading_views;
3939
3940         if ((loading == FALSE && loading_views-- == 1) ||
3941             (loading == TRUE  && loading_views++ == 0))
3942                 nodelay(status_win, loading);
3943 }
3944
3945 static void
3946 init_display(void)
3947 {
3948         int x, y;
3949
3950         /* Initialize the curses library */
3951         if (isatty(STDIN_FILENO)) {
3952                 cursed = !!initscr();
3953         } else {
3954                 /* Leave stdin and stdout alone when acting as a pager. */
3955                 FILE *io = fopen("/dev/tty", "r+");
3956
3957                 if (!io)
3958                         die("Failed to open /dev/tty");
3959                 cursed = !!newterm(NULL, io, io);
3960         }
3961
3962         if (!cursed)
3963                 die("Failed to initialize curses");
3964
3965         nonl();         /* Tell curses not to do NL->CR/NL on output */
3966         cbreak();       /* Take input chars one at a time, no wait for \n */
3967         noecho();       /* Don't echo input */
3968         leaveok(stdscr, TRUE);
3969
3970         if (has_colors())
3971                 init_colors();
3972
3973         getmaxyx(stdscr, y, x);
3974         status_win = newwin(1, 0, y - 1, 0);
3975         if (!status_win)
3976                 die("Failed to create status window");
3977
3978         /* Enable keyboard mapping */
3979         keypad(status_win, TRUE);
3980         wbkgdset(status_win, get_line_attr(LINE_STATUS));
3981 }
3982
3983 static char *
3984 read_prompt(const char *prompt)
3985 {
3986         enum { READING, STOP, CANCEL } status = READING;
3987         static char buf[sizeof(opt_cmd) - STRING_SIZE("git \0")];
3988         int pos = 0;
3989
3990         while (status == READING) {
3991                 struct view *view;
3992                 int i, key;
3993
3994                 input_mode = TRUE;
3995
3996                 foreach_view (view, i)
3997                         update_view(view);
3998
3999                 input_mode = FALSE;
4000
4001                 mvwprintw(status_win, 0, 0, "%s%.*s", prompt, pos, buf);
4002                 wclrtoeol(status_win);
4003
4004                 /* Refresh, accept single keystroke of input */
4005                 key = wgetch(status_win);
4006                 switch (key) {
4007                 case KEY_RETURN:
4008                 case KEY_ENTER:
4009                 case '\n':
4010                         status = pos ? STOP : CANCEL;
4011                         break;
4012
4013                 case KEY_BACKSPACE:
4014                         if (pos > 0)
4015                                 pos--;
4016                         else
4017                                 status = CANCEL;
4018                         break;
4019
4020                 case KEY_ESC:
4021                         status = CANCEL;
4022                         break;
4023
4024                 case ERR:
4025                         break;
4026
4027                 default:
4028                         if (pos >= sizeof(buf)) {
4029                                 report("Input string too long");
4030                                 return NULL;
4031                         }
4032
4033                         if (isprint(key))
4034                                 buf[pos++] = (char) key;
4035                 }
4036         }
4037
4038         /* Clear the status window */
4039         status_empty = FALSE;
4040         report("");
4041
4042         if (status == CANCEL)
4043                 return NULL;
4044
4045         buf[pos++] = 0;
4046
4047         return buf;
4048 }
4049
4050 /*
4051  * Repository references
4052  */
4053
4054 static struct ref *refs;
4055 static size_t refs_size;
4056
4057 /* Id <-> ref store */
4058 static struct ref ***id_refs;
4059 static size_t id_refs_size;
4060
4061 static struct ref **
4062 get_refs(char *id)
4063 {
4064         struct ref ***tmp_id_refs;
4065         struct ref **ref_list = NULL;
4066         size_t ref_list_size = 0;
4067         size_t i;
4068
4069         for (i = 0; i < id_refs_size; i++)
4070                 if (!strcmp(id, id_refs[i][0]->id))
4071                         return id_refs[i];
4072
4073         tmp_id_refs = realloc(id_refs, (id_refs_size + 1) * sizeof(*id_refs));
4074         if (!tmp_id_refs)
4075                 return NULL;
4076
4077         id_refs = tmp_id_refs;
4078
4079         for (i = 0; i < refs_size; i++) {
4080                 struct ref **tmp;
4081
4082                 if (strcmp(id, refs[i].id))
4083                         continue;
4084
4085                 tmp = realloc(ref_list, (ref_list_size + 1) * sizeof(*ref_list));
4086                 if (!tmp) {
4087                         if (ref_list)
4088                                 free(ref_list);
4089                         return NULL;
4090                 }
4091
4092                 ref_list = tmp;
4093                 if (ref_list_size > 0)
4094                         ref_list[ref_list_size - 1]->next = 1;
4095                 ref_list[ref_list_size] = &refs[i];
4096
4097                 /* XXX: The properties of the commit chains ensures that we can
4098                  * safely modify the shared ref. The repo references will
4099                  * always be similar for the same id. */
4100                 ref_list[ref_list_size]->next = 0;
4101                 ref_list_size++;
4102         }
4103
4104         if (ref_list)
4105                 id_refs[id_refs_size++] = ref_list;
4106
4107         return ref_list;
4108 }
4109
4110 static int
4111 read_ref(char *id, size_t idlen, char *name, size_t namelen)
4112 {
4113         struct ref *ref;
4114         bool tag = FALSE;
4115         bool remote = FALSE;
4116
4117         if (!strncmp(name, "refs/tags/", STRING_SIZE("refs/tags/"))) {
4118                 /* Commits referenced by tags has "^{}" appended. */
4119                 if (name[namelen - 1] != '}')
4120                         return OK;
4121
4122                 while (namelen > 0 && name[namelen] != '^')
4123                         namelen--;
4124
4125                 tag = TRUE;
4126                 namelen -= STRING_SIZE("refs/tags/");
4127                 name    += STRING_SIZE("refs/tags/");
4128
4129         } else if (!strncmp(name, "refs/remotes/", STRING_SIZE("refs/remotes/"))) {
4130                 remote = TRUE;
4131                 namelen -= STRING_SIZE("refs/remotes/");
4132                 name    += STRING_SIZE("refs/remotes/");
4133
4134         } else if (!strncmp(name, "refs/heads/", STRING_SIZE("refs/heads/"))) {
4135                 namelen -= STRING_SIZE("refs/heads/");
4136                 name    += STRING_SIZE("refs/heads/");
4137
4138         } else if (!strcmp(name, "HEAD")) {
4139                 return OK;
4140         }
4141
4142         refs = realloc(refs, sizeof(*refs) * (refs_size + 1));
4143         if (!refs)
4144                 return ERR;
4145
4146         ref = &refs[refs_size++];
4147         ref->name = malloc(namelen + 1);
4148         if (!ref->name)
4149                 return ERR;
4150
4151         strncpy(ref->name, name, namelen);
4152         ref->name[namelen] = 0;
4153         ref->tag = tag;
4154         ref->remote = remote;
4155         string_copy_rev(ref->id, id);
4156
4157         return OK;
4158 }
4159
4160 static int
4161 load_refs(void)
4162 {
4163         const char *cmd_env = getenv("TIG_LS_REMOTE");
4164         const char *cmd = cmd_env && *cmd_env ? cmd_env : TIG_LS_REMOTE;
4165
4166         return read_properties(popen(cmd, "r"), "\t", read_ref);
4167 }
4168
4169 static int
4170 read_repo_config_option(char *name, size_t namelen, char *value, size_t valuelen)
4171 {
4172         if (!strcmp(name, "i18n.commitencoding"))
4173                 string_ncopy(opt_encoding, value, valuelen);
4174
4175         return OK;
4176 }
4177
4178 static int
4179 load_repo_config(void)
4180 {
4181         return read_properties(popen("git repo-config --list", "r"),
4182                                "=", read_repo_config_option);
4183 }
4184
4185 static int
4186 read_repo_info(char *name, size_t namelen, char *value, size_t valuelen)
4187 {
4188         if (!opt_git_dir[0])
4189                 string_ncopy(opt_git_dir, name, namelen);
4190         else
4191                 string_ncopy(opt_cdup, name, namelen);
4192         return OK;
4193 }
4194
4195 /* XXX: The line outputted by "--show-cdup" can be empty so the option
4196  * must be the last one! */
4197 static int
4198 load_repo_info(void)
4199 {
4200         return read_properties(popen("git rev-parse --git-dir --show-cdup 2>/dev/null", "r"),
4201                                "=", read_repo_info);
4202 }
4203
4204 static int
4205 read_properties(FILE *pipe, const char *separators,
4206                 int (*read_property)(char *, size_t, char *, size_t))
4207 {
4208         char buffer[BUFSIZ];
4209         char *name;
4210         int state = OK;
4211
4212         if (!pipe)
4213                 return ERR;
4214
4215         while (state == OK && (name = fgets(buffer, sizeof(buffer), pipe))) {
4216                 char *value;
4217                 size_t namelen;
4218                 size_t valuelen;
4219
4220                 name = chomp_string(name);
4221                 namelen = strcspn(name, separators);
4222
4223                 if (name[namelen]) {
4224                         name[namelen] = 0;
4225                         value = chomp_string(name + namelen + 1);
4226                         valuelen = strlen(value);
4227
4228                 } else {
4229                         value = "";
4230                         valuelen = 0;
4231                 }
4232
4233                 state = read_property(name, namelen, value, valuelen);
4234         }
4235
4236         if (state != ERR && ferror(pipe))
4237                 state = ERR;
4238
4239         pclose(pipe);
4240
4241         return state;
4242 }
4243
4244
4245 /*
4246  * Main
4247  */
4248
4249 static void __NORETURN
4250 quit(int sig)
4251 {
4252         /* XXX: Restore tty modes and let the OS cleanup the rest! */
4253         if (cursed)
4254                 endwin();
4255         exit(0);
4256 }
4257
4258 static void __NORETURN
4259 die(const char *err, ...)
4260 {
4261         va_list args;
4262
4263         endwin();
4264
4265         va_start(args, err);
4266         fputs("tig: ", stderr);
4267         vfprintf(stderr, err, args);
4268         fputs("\n", stderr);
4269         va_end(args);
4270
4271         exit(1);
4272 }
4273
4274 int
4275 main(int argc, char *argv[])
4276 {
4277         struct view *view;
4278         enum request request;
4279         size_t i;
4280
4281         signal(SIGINT, quit);
4282
4283         if (setlocale(LC_ALL, "")) {
4284                 char *codeset = nl_langinfo(CODESET);
4285
4286                 string_ncopy(opt_codeset, codeset, strlen(codeset));
4287         }
4288
4289         if (load_repo_info() == ERR)
4290                 die("Failed to load repo info.");
4291
4292         /* Require a git repository unless when running in pager mode. */
4293         if (!opt_git_dir[0])
4294                 die("Not a git repository");
4295
4296         if (load_options() == ERR)
4297                 die("Failed to load user config.");
4298
4299         /* Load the repo config file so options can be overwritten from
4300          * the command line. */
4301         if (load_repo_config() == ERR)
4302                 die("Failed to load repo config.");
4303
4304         if (!parse_options(argc, argv))
4305                 return 0;
4306
4307         if (*opt_codeset && strcmp(opt_codeset, opt_encoding)) {
4308                 opt_iconv = iconv_open(opt_codeset, opt_encoding);
4309                 if (opt_iconv == ICONV_NONE)
4310                         die("Failed to initialize character set conversion");
4311         }
4312
4313         if (load_refs() == ERR)
4314                 die("Failed to load refs.");
4315
4316         for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
4317                 view->cmd_env = getenv(view->cmd_env);
4318
4319         request = opt_request;
4320
4321         init_display();
4322
4323         while (view_driver(display[current_view], request)) {
4324                 int key;
4325                 int i;
4326
4327                 foreach_view (view, i)
4328                         update_view(view);
4329
4330                 /* Refresh, accept single keystroke of input */
4331                 key = wgetch(status_win);
4332
4333                 /* wgetch() with nodelay() enabled returns ERR when there's no
4334                  * input. */
4335                 if (key == ERR) {
4336                         request = REQ_NONE;
4337                         continue;
4338                 }
4339
4340                 request = get_keybinding(display[current_view]->keymap, key);
4341
4342                 /* Some low-level request handling. This keeps access to
4343                  * status_win restricted. */
4344                 switch (request) {
4345                 case REQ_PROMPT:
4346                 {
4347                         char *cmd = read_prompt(":");
4348
4349                         if (cmd && string_format(opt_cmd, "git %s", cmd)) {
4350                                 if (strncmp(cmd, "show", 4) && isspace(cmd[4])) {
4351                                         opt_request = REQ_VIEW_DIFF;
4352                                 } else {
4353                                         opt_request = REQ_VIEW_PAGER;
4354                                 }
4355                                 break;
4356                         }
4357
4358                         request = REQ_NONE;
4359                         break;
4360                 }
4361                 case REQ_SEARCH:
4362                 case REQ_SEARCH_BACK:
4363                 {
4364                         const char *prompt = request == REQ_SEARCH
4365                                            ? "/" : "?";
4366                         char *search = read_prompt(prompt);
4367
4368                         if (search)
4369                                 string_ncopy(opt_search, search, strlen(search));
4370                         else
4371                                 request = REQ_NONE;
4372                         break;
4373                 }
4374                 case REQ_SCREEN_RESIZE:
4375                 {
4376                         int height, width;
4377
4378                         getmaxyx(stdscr, height, width);
4379
4380                         /* Resize the status view and let the view driver take
4381                          * care of resizing the displayed views. */
4382                         wresize(status_win, 1, width);
4383                         mvwin(status_win, height - 1, 0);
4384                         wrefresh(status_win);
4385                         break;
4386                 }
4387                 default:
4388                         break;
4389                 }
4390         }
4391
4392         quit(0);
4393
4394         return 0;
4395 }