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

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