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 io->pid == 0 || 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", "--root", "--patch-with-stat",
4169                                         "-C", "-M", "HEAD", "--", view->vid, NULL
4170                         };
4171
4172                         if (!blame->commit->has_previous) {
4173                                 diff_index_argv[1] = "diff";
4174                                 diff_index_argv[2] = "--no-color";
4175                                 diff_index_argv[5] = "--";
4176                                 diff_index_argv[6] = "/dev/null";
4177                         }
4178
4179                         if (!prepare_update(diff, diff_index_argv, NULL, FORMAT_DASH)) {
4180                                 report("Failed to allocate diff command");
4181                                 break;
4182                         }
4183                         flags |= OPEN_PREPARED;
4184                 }
4185
4186                 open_view(view, REQ_VIEW_DIFF, flags);
4187                 if (VIEW(REQ_VIEW_DIFF)->pipe && !strcmp(blame->commit->id, NULL_ID))
4188                         string_copy_rev(VIEW(REQ_VIEW_DIFF)->ref, NULL_ID);
4189                 break;
4190
4191         default:
4192                 return request;
4193         }
4194
4195         return REQ_NONE;
4196 }
4197
4198 static bool
4199 blame_grep(struct view *view, struct line *line)
4200 {
4201         struct blame *blame = line->data;
4202         struct blame_commit *commit = blame->commit;
4203         regmatch_t pmatch;
4204
4205 #define MATCH(text, on)                                                 \
4206         (on && *text && regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
4207
4208         if (commit) {
4209                 char buf[DATE_COLS + 1];
4210
4211                 if (MATCH(commit->title, 1) ||
4212                     MATCH(commit->author, opt_author) ||
4213                     MATCH(commit->id, opt_date))
4214                         return TRUE;
4215
4216                 if (strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time) &&
4217                     MATCH(buf, 1))
4218                         return TRUE;
4219         }
4220
4221         return MATCH(blame->text, 1);
4222
4223 #undef MATCH
4224 }
4225
4226 static void
4227 blame_select(struct view *view, struct line *line)
4228 {
4229         struct blame *blame = line->data;
4230         struct blame_commit *commit = blame->commit;
4231
4232         if (!commit)
4233                 return;
4234
4235         if (!strcmp(commit->id, NULL_ID))
4236                 string_ncopy(ref_commit, "HEAD", 4);
4237         else
4238                 string_copy_rev(ref_commit, commit->id);
4239 }
4240
4241 static struct view_ops blame_ops = {
4242         "line",
4243         NULL,
4244         blame_open,
4245         blame_read,
4246         blame_draw,
4247         blame_request,
4248         blame_grep,
4249         blame_select,
4250 };
4251
4252 /*
4253  * Status backend
4254  */
4255
4256 struct status {
4257         char status;
4258         struct {
4259                 mode_t mode;
4260                 char rev[SIZEOF_REV];
4261                 char name[SIZEOF_STR];
4262         } old;
4263         struct {
4264                 mode_t mode;
4265                 char rev[SIZEOF_REV];
4266                 char name[SIZEOF_STR];
4267         } new;
4268 };
4269
4270 static char status_onbranch[SIZEOF_STR];
4271 static struct status stage_status;
4272 static enum line_type stage_line_type;
4273 static size_t stage_chunks;
4274 static int *stage_chunk;
4275
4276 /* This should work even for the "On branch" line. */
4277 static inline bool
4278 status_has_none(struct view *view, struct line *line)
4279 {
4280         return line < view->line + view->lines && !line[1].data;
4281 }
4282
4283 /* Get fields from the diff line:
4284  * :100644 100644 06a5d6ae9eca55be2e0e585a152e6b1336f2b20e 0000000000000000000000000000000000000000 M
4285  */
4286 static inline bool
4287 status_get_diff(struct status *file, const char *buf, size_t bufsize)
4288 {
4289         const char *old_mode = buf +  1;
4290         const char *new_mode = buf +  8;
4291         const char *old_rev  = buf + 15;
4292         const char *new_rev  = buf + 56;
4293         const char *status   = buf + 97;
4294
4295         if (bufsize < 98 ||
4296             old_mode[-1] != ':' ||
4297             new_mode[-1] != ' ' ||
4298             old_rev[-1]  != ' ' ||
4299             new_rev[-1]  != ' ' ||
4300             status[-1]   != ' ')
4301                 return FALSE;
4302
4303         file->status = *status;
4304
4305         string_copy_rev(file->old.rev, old_rev);
4306         string_copy_rev(file->new.rev, new_rev);
4307
4308         file->old.mode = strtoul(old_mode, NULL, 8);
4309         file->new.mode = strtoul(new_mode, NULL, 8);
4310
4311         file->old.name[0] = file->new.name[0] = 0;
4312
4313         return TRUE;
4314 }
4315
4316 static bool
4317 status_run(struct view *view, const char *argv[], char status, enum line_type type)
4318 {
4319         struct status *file = NULL;
4320         struct status *unmerged = NULL;
4321         char *buf;
4322         struct io io = {};
4323
4324         if (!run_io(&io, argv, NULL, IO_RD))
4325                 return FALSE;
4326
4327         add_line_data(view, NULL, type);
4328
4329         while ((buf = io_get(&io, 0, TRUE))) {
4330                 if (!file) {
4331                         file = calloc(1, sizeof(*file));
4332                         if (!file || !add_line_data(view, file, type))
4333                                 goto error_out;
4334                 }
4335
4336                 /* Parse diff info part. */
4337                 if (status) {
4338                         file->status = status;
4339                         if (status == 'A')
4340                                 string_copy(file->old.rev, NULL_ID);
4341
4342                 } else if (!file->status) {
4343                         if (!status_get_diff(file, buf, strlen(buf)))
4344                                 goto error_out;
4345
4346                         buf = io_get(&io, 0, TRUE);
4347                         if (!buf)
4348                                 break;
4349
4350                         /* Collapse all 'M'odified entries that follow a
4351                          * associated 'U'nmerged entry. */
4352                         if (file->status == 'U') {
4353                                 unmerged = file;
4354
4355                         } else if (unmerged) {
4356                                 int collapse = !strcmp(buf, unmerged->new.name);
4357
4358                                 unmerged = NULL;
4359                                 if (collapse) {
4360                                         free(file);
4361                                         view->lines--;
4362                                         continue;
4363                                 }
4364                         }
4365                 }
4366
4367                 /* Grab the old name for rename/copy. */
4368                 if (!*file->old.name &&
4369                     (file->status == 'R' || file->status == 'C')) {
4370                         string_ncopy(file->old.name, buf, strlen(buf));
4371
4372                         buf = io_get(&io, 0, TRUE);
4373                         if (!buf)
4374                                 break;
4375                 }
4376
4377                 /* git-ls-files just delivers a NUL separated list of
4378                  * file names similar to the second half of the
4379                  * git-diff-* output. */
4380                 string_ncopy(file->new.name, buf, strlen(buf));
4381                 if (!*file->old.name)
4382                         string_copy(file->old.name, file->new.name);
4383                 file = NULL;
4384         }
4385
4386         if (io_error(&io)) {
4387 error_out:
4388                 done_io(&io);
4389                 return FALSE;
4390         }
4391
4392         if (!view->line[view->lines - 1].data)
4393                 add_line_data(view, NULL, LINE_STAT_NONE);
4394
4395         done_io(&io);
4396         return TRUE;
4397 }
4398
4399 /* Don't show unmerged entries in the staged section. */
4400 static const char *status_diff_index_argv[] = {
4401         "git", "diff-index", "-z", "--diff-filter=ACDMRTXB",
4402                              "--cached", "-M", "HEAD", NULL
4403 };
4404
4405 static const char *status_diff_files_argv[] = {
4406         "git", "diff-files", "-z", NULL
4407 };
4408
4409 static const char *status_list_other_argv[] = {
4410         "git", "ls-files", "-z", "--others", "--exclude-standard", NULL
4411 };
4412
4413 static const char *status_list_no_head_argv[] = {
4414         "git", "ls-files", "-z", "--cached", "--exclude-standard", NULL
4415 };
4416
4417 static const char *update_index_argv[] = {
4418         "git", "update-index", "-q", "--unmerged", "--refresh", NULL
4419 };
4420
4421 /* Restore the previous line number to stay in the context or select a
4422  * line with something that can be updated. */
4423 static void
4424 status_restore(struct view *view)
4425 {
4426         if (view->p_lineno >= view->lines)
4427                 view->p_lineno = view->lines - 1;
4428         while (view->p_lineno < view->lines && !view->line[view->p_lineno].data)
4429                 view->p_lineno++;
4430         while (view->p_lineno > 0 && !view->line[view->p_lineno].data)
4431                 view->p_lineno--;
4432
4433         /* If the above fails, always skip the "On branch" line. */
4434         if (view->p_lineno < view->lines)
4435                 view->lineno = view->p_lineno;
4436         else
4437                 view->lineno = 1;
4438
4439         if (view->lineno < view->offset)
4440                 view->offset = view->lineno;
4441         else if (view->offset + view->height <= view->lineno)
4442                 view->offset = view->lineno - view->height + 1;
4443
4444         view->p_restore = FALSE;
4445 }
4446
4447 /* First parse staged info using git-diff-index(1), then parse unstaged
4448  * info using git-diff-files(1), and finally untracked files using
4449  * git-ls-files(1). */
4450 static bool
4451 status_open(struct view *view)
4452 {
4453         reset_view(view);
4454
4455         add_line_data(view, NULL, LINE_STAT_HEAD);
4456         if (is_initial_commit())
4457                 string_copy(status_onbranch, "Initial commit");
4458         else if (!*opt_head)
4459                 string_copy(status_onbranch, "Not currently on any branch");
4460         else if (!string_format(status_onbranch, "On branch %s", opt_head))
4461                 return FALSE;
4462
4463         run_io_bg(update_index_argv);
4464
4465         if (is_initial_commit()) {
4466                 if (!status_run(view, status_list_no_head_argv, 'A', LINE_STAT_STAGED))
4467                         return FALSE;
4468         } else if (!status_run(view, status_diff_index_argv, 0, LINE_STAT_STAGED)) {
4469                 return FALSE;
4470         }
4471
4472         if (!status_run(view, status_diff_files_argv, 0, LINE_STAT_UNSTAGED) ||
4473             !status_run(view, status_list_other_argv, '?', LINE_STAT_UNTRACKED))
4474                 return FALSE;
4475
4476         /* Restore the exact position or use the specialized restore
4477          * mode? */
4478         if (!view->p_restore)
4479                 status_restore(view);
4480         return TRUE;
4481 }
4482
4483 static bool
4484 status_draw(struct view *view, struct line *line, unsigned int lineno)
4485 {
4486         struct status *status = line->data;
4487         enum line_type type;
4488         const char *text;
4489
4490         if (!status) {
4491                 switch (line->type) {
4492                 case LINE_STAT_STAGED:
4493                         type = LINE_STAT_SECTION;
4494                         text = "Changes to be committed:";
4495                         break;
4496
4497                 case LINE_STAT_UNSTAGED:
4498                         type = LINE_STAT_SECTION;
4499                         text = "Changed but not updated:";
4500                         break;
4501
4502                 case LINE_STAT_UNTRACKED:
4503                         type = LINE_STAT_SECTION;
4504                         text = "Untracked files:";
4505                         break;
4506
4507                 case LINE_STAT_NONE:
4508                         type = LINE_DEFAULT;
4509                         text = "    (no files)";
4510                         break;
4511
4512                 case LINE_STAT_HEAD:
4513                         type = LINE_STAT_HEAD;
4514                         text = status_onbranch;
4515                         break;
4516
4517                 default:
4518                         return FALSE;
4519                 }
4520         } else {
4521                 static char buf[] = { '?', ' ', ' ', ' ', 0 };
4522
4523                 buf[0] = status->status;
4524                 if (draw_text(view, line->type, buf, TRUE))
4525                         return TRUE;
4526                 type = LINE_DEFAULT;
4527                 text = status->new.name;
4528         }
4529
4530         draw_text(view, type, text, TRUE);
4531         return TRUE;
4532 }
4533
4534 static enum request
4535 status_enter(struct view *view, struct line *line)
4536 {
4537         struct status *status = line->data;
4538         const char *oldpath = status ? status->old.name : NULL;
4539         /* Diffs for unmerged entries are empty when passing the new
4540          * path, so leave it empty. */
4541         const char *newpath = status && status->status != 'U' ? status->new.name : NULL;
4542         const char *info;
4543         enum open_flags split;
4544         struct view *stage = VIEW(REQ_VIEW_STAGE);
4545
4546         if (line->type == LINE_STAT_NONE ||
4547             (!status && line[1].type == LINE_STAT_NONE)) {
4548                 report("No file to diff");
4549                 return REQ_NONE;
4550         }
4551
4552         switch (line->type) {
4553         case LINE_STAT_STAGED:
4554                 if (is_initial_commit()) {
4555                         const char *no_head_diff_argv[] = {
4556                                 "git", "diff", "--no-color", "--patch-with-stat",
4557                                         "--", "/dev/null", newpath, NULL
4558                         };
4559
4560                         if (!prepare_update(stage, no_head_diff_argv, opt_cdup, FORMAT_DASH))
4561                                 return REQ_QUIT;
4562                 } else {
4563                         const char *index_show_argv[] = {
4564                                 "git", "diff-index", "--root", "--patch-with-stat",
4565                                         "-C", "-M", "--cached", "HEAD", "--",
4566                                         oldpath, newpath, NULL
4567                         };
4568
4569                         if (!prepare_update(stage, index_show_argv, opt_cdup, FORMAT_DASH))
4570                                 return REQ_QUIT;
4571                 }
4572
4573                 if (status)
4574                         info = "Staged changes to %s";
4575                 else
4576                         info = "Staged changes";
4577                 break;
4578
4579         case LINE_STAT_UNSTAGED:
4580         {
4581                 const char *files_show_argv[] = {
4582                         "git", "diff-files", "--root", "--patch-with-stat",
4583                                 "-C", "-M", "--", oldpath, newpath, NULL
4584                 };
4585
4586                 if (!prepare_update(stage, files_show_argv, opt_cdup, FORMAT_DASH))
4587                         return REQ_QUIT;
4588                 if (status)
4589                         info = "Unstaged changes to %s";
4590                 else
4591                         info = "Unstaged changes";
4592                 break;
4593         }
4594         case LINE_STAT_UNTRACKED:
4595                 if (!newpath) {
4596                         report("No file to show");
4597                         return REQ_NONE;
4598                 }
4599
4600                 if (!suffixcmp(status->new.name, -1, "/")) {
4601                         report("Cannot display a directory");
4602                         return REQ_NONE;
4603                 }
4604
4605                 if (!prepare_update_file(stage, newpath))
4606                         return REQ_QUIT;
4607                 info = "Untracked file %s";
4608                 break;
4609
4610         case LINE_STAT_HEAD:
4611                 return REQ_NONE;
4612
4613         default:
4614                 die("line type %d not handled in switch", line->type);
4615         }
4616
4617         split = view_is_displayed(view) ? OPEN_SPLIT : 0;
4618         open_view(view, REQ_VIEW_STAGE, OPEN_PREPARED | split);
4619         if (view_is_displayed(VIEW(REQ_VIEW_STAGE))) {
4620                 if (status) {
4621                         stage_status = *status;
4622                 } else {
4623                         memset(&stage_status, 0, sizeof(stage_status));
4624                 }
4625
4626                 stage_line_type = line->type;
4627                 stage_chunks = 0;
4628                 string_format(VIEW(REQ_VIEW_STAGE)->ref, info, stage_status.new.name);
4629         }
4630
4631         return REQ_NONE;
4632 }
4633
4634 static bool
4635 status_exists(struct status *status, enum line_type type)
4636 {
4637         struct view *view = VIEW(REQ_VIEW_STATUS);
4638         unsigned long lineno;
4639
4640         for (lineno = 0; lineno < view->lines; lineno++) {
4641                 struct line *line = &view->line[lineno];
4642                 struct status *pos = line->data;
4643
4644                 if (line->type != type)
4645                         continue;
4646                 if (!pos && (!status || !status->status) && line[1].data) {
4647                         select_view_line(view, lineno);
4648                         return TRUE;
4649                 }
4650                 if (pos && !strcmp(status->new.name, pos->new.name)) {
4651                         select_view_line(view, lineno);
4652                         return TRUE;
4653                 }
4654         }
4655
4656         return FALSE;
4657 }
4658
4659
4660 static bool
4661 status_update_prepare(struct io *io, enum line_type type)
4662 {
4663         const char *staged_argv[] = {
4664                 "git", "update-index", "-z", "--index-info", NULL
4665         };
4666         const char *others_argv[] = {
4667                 "git", "update-index", "-z", "--add", "--remove", "--stdin", NULL
4668         };
4669
4670         switch (type) {
4671         case LINE_STAT_STAGED:
4672                 return run_io(io, staged_argv, opt_cdup, IO_WR);
4673
4674         case LINE_STAT_UNSTAGED:
4675                 return run_io(io, others_argv, opt_cdup, IO_WR);
4676
4677         case LINE_STAT_UNTRACKED:
4678                 return run_io(io, others_argv, NULL, IO_WR);
4679
4680         default:
4681                 die("line type %d not handled in switch", type);
4682                 return FALSE;
4683         }
4684 }
4685
4686 static bool
4687 status_update_write(struct io *io, struct status *status, enum line_type type)
4688 {
4689         char buf[SIZEOF_STR];
4690         size_t bufsize = 0;
4691
4692         switch (type) {
4693         case LINE_STAT_STAGED:
4694                 if (!string_format_from(buf, &bufsize, "%06o %s\t%s%c",
4695                                         status->old.mode,
4696                                         status->old.rev,
4697                                         status->old.name, 0))
4698                         return FALSE;
4699                 break;
4700
4701         case LINE_STAT_UNSTAGED:
4702         case LINE_STAT_UNTRACKED:
4703                 if (!string_format_from(buf, &bufsize, "%s%c", status->new.name, 0))
4704                         return FALSE;
4705                 break;
4706
4707         default:
4708                 die("line type %d not handled in switch", type);
4709         }
4710
4711         return io_write(io, buf, bufsize);
4712 }
4713
4714 static bool
4715 status_update_file(struct status *status, enum line_type type)
4716 {
4717         struct io io = {};
4718         bool result;
4719
4720         if (!status_update_prepare(&io, type))
4721                 return FALSE;
4722
4723         result = status_update_write(&io, status, type);
4724         done_io(&io);
4725         return result;
4726 }
4727
4728 static bool
4729 status_update_files(struct view *view, struct line *line)
4730 {
4731         struct io io = {};
4732         bool result = TRUE;
4733         struct line *pos = view->line + view->lines;
4734         int files = 0;
4735         int file, done;
4736
4737         if (!status_update_prepare(&io, line->type))
4738                 return FALSE;
4739
4740         for (pos = line; pos < view->line + view->lines && pos->data; pos++)
4741                 files++;
4742
4743         for (file = 0, done = 0; result && file < files; line++, file++) {
4744                 int almost_done = file * 100 / files;
4745
4746                 if (almost_done > done) {
4747                         done = almost_done;
4748                         string_format(view->ref, "updating file %u of %u (%d%% done)",
4749                                       file, files, done);
4750                         update_view_title(view);
4751                 }
4752                 result = status_update_write(&io, line->data, line->type);
4753         }
4754
4755         done_io(&io);
4756         return result;
4757 }
4758
4759 static bool
4760 status_update(struct view *view)
4761 {
4762         struct line *line = &view->line[view->lineno];
4763
4764         assert(view->lines);
4765
4766         if (!line->data) {
4767                 /* This should work even for the "On branch" line. */
4768                 if (line < view->line + view->lines && !line[1].data) {
4769                         report("Nothing to update");
4770                         return FALSE;
4771                 }
4772
4773                 if (!status_update_files(view, line + 1)) {
4774                         report("Failed to update file status");
4775                         return FALSE;
4776                 }
4777
4778         } else if (!status_update_file(line->data, line->type)) {
4779                 report("Failed to update file status");
4780                 return FALSE;
4781         }
4782
4783         return TRUE;
4784 }
4785
4786 static bool
4787 status_revert(struct status *status, enum line_type type, bool has_none)
4788 {
4789         if (!status || type != LINE_STAT_UNSTAGED) {
4790                 if (type == LINE_STAT_STAGED) {
4791                         report("Cannot revert changes to staged files");
4792                 } else if (type == LINE_STAT_UNTRACKED) {
4793                         report("Cannot revert changes to untracked files");
4794                 } else if (has_none) {
4795                         report("Nothing to revert");
4796                 } else {
4797                         report("Cannot revert changes to multiple files");
4798                 }
4799                 return FALSE;
4800
4801         } else {
4802                 const char *checkout_argv[] = {
4803                         "git", "checkout", "--", status->old.name, NULL
4804                 };
4805
4806                 if (!prompt_yesno("Are you sure you want to overwrite any changes?"))
4807                         return FALSE;
4808                 return run_io_fg(checkout_argv, opt_cdup);
4809         }
4810 }
4811
4812 static enum request
4813 status_request(struct view *view, enum request request, struct line *line)
4814 {
4815         struct status *status = line->data;
4816
4817         switch (request) {
4818         case REQ_STATUS_UPDATE:
4819                 if (!status_update(view))
4820                         return REQ_NONE;
4821                 break;
4822
4823         case REQ_STATUS_REVERT:
4824                 if (!status_revert(status, line->type, status_has_none(view, line)))
4825                         return REQ_NONE;
4826                 break;
4827
4828         case REQ_STATUS_MERGE:
4829                 if (!status || status->status != 'U') {
4830                         report("Merging only possible for files with unmerged status ('U').");
4831                         return REQ_NONE;
4832                 }
4833                 open_mergetool(status->new.name);
4834                 break;
4835
4836         case REQ_EDIT:
4837                 if (!status)
4838                         return request;
4839                 if (status->status == 'D') {
4840                         report("File has been deleted.");
4841                         return REQ_NONE;
4842                 }
4843
4844                 open_editor(status->status != '?', status->new.name);
4845                 break;
4846
4847         case REQ_VIEW_BLAME:
4848                 if (status) {
4849                         string_copy(opt_file, status->new.name);
4850                         opt_ref[0] = 0;
4851                 }
4852                 return request;
4853
4854         case REQ_ENTER:
4855                 /* After returning the status view has been split to
4856                  * show the stage view. No further reloading is
4857                  * necessary. */
4858                 status_enter(view, line);
4859                 return REQ_NONE;
4860
4861         case REQ_REFRESH:
4862                 /* Simply reload the view. */
4863                 break;
4864
4865         default:
4866                 return request;
4867         }
4868
4869         open_view(view, REQ_VIEW_STATUS, OPEN_RELOAD);
4870
4871         return REQ_NONE;
4872 }
4873
4874 static void
4875 status_select(struct view *view, struct line *line)
4876 {
4877         struct status *status = line->data;
4878         char file[SIZEOF_STR] = "all files";
4879         const char *text;
4880         const char *key;
4881
4882         if (status && !string_format(file, "'%s'", status->new.name))
4883                 return;
4884
4885         if (!status && line[1].type == LINE_STAT_NONE)
4886                 line++;
4887
4888         switch (line->type) {
4889         case LINE_STAT_STAGED:
4890                 text = "Press %s to unstage %s for commit";
4891                 break;
4892
4893         case LINE_STAT_UNSTAGED:
4894                 text = "Press %s to stage %s for commit";
4895                 break;
4896
4897         case LINE_STAT_UNTRACKED:
4898                 text = "Press %s to stage %s for addition";
4899                 break;
4900
4901         case LINE_STAT_HEAD:
4902         case LINE_STAT_NONE:
4903                 text = "Nothing to update";
4904                 break;
4905
4906         default:
4907                 die("line type %d not handled in switch", line->type);
4908         }
4909
4910         if (status && status->status == 'U') {
4911                 text = "Press %s to resolve conflict in %s";
4912                 key = get_key(REQ_STATUS_MERGE);
4913
4914         } else {
4915                 key = get_key(REQ_STATUS_UPDATE);
4916         }
4917
4918         string_format(view->ref, text, key, file);
4919 }
4920
4921 static bool
4922 status_grep(struct view *view, struct line *line)
4923 {
4924         struct status *status = line->data;
4925         enum { S_STATUS, S_NAME, S_END } state;
4926         char buf[2] = "?";
4927         regmatch_t pmatch;
4928
4929         if (!status)
4930                 return FALSE;
4931
4932         for (state = S_STATUS; state < S_END; state++) {
4933                 const char *text;
4934
4935                 switch (state) {
4936                 case S_NAME:    text = status->new.name;        break;
4937                 case S_STATUS:
4938                         buf[0] = status->status;
4939                         text = buf;
4940                         break;
4941
4942                 default:
4943                         return FALSE;
4944                 }
4945
4946                 if (regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
4947                         return TRUE;
4948         }
4949
4950         return FALSE;
4951 }
4952
4953 static struct view_ops status_ops = {
4954         "file",
4955         NULL,
4956         status_open,
4957         NULL,
4958         status_draw,
4959         status_request,
4960         status_grep,
4961         status_select,
4962 };
4963
4964
4965 static bool
4966 stage_diff_write(struct io *io, struct line *line, struct line *end)
4967 {
4968         while (line < end) {
4969                 if (!io_write(io, line->data, strlen(line->data)) ||
4970                     !io_write(io, "\n", 1))
4971                         return FALSE;
4972                 line++;
4973                 if (line->type == LINE_DIFF_CHUNK ||
4974                     line->type == LINE_DIFF_HEADER)
4975                         break;
4976         }
4977
4978         return TRUE;
4979 }
4980
4981 static struct line *
4982 stage_diff_find(struct view *view, struct line *line, enum line_type type)
4983 {
4984         for (; view->line < line; line--)
4985                 if (line->type == type)
4986                         return line;
4987
4988         return NULL;
4989 }
4990
4991 static bool
4992 stage_apply_chunk(struct view *view, struct line *chunk, bool revert)
4993 {
4994         const char *apply_argv[SIZEOF_ARG] = {
4995                 "git", "apply", "--whitespace=nowarn", NULL
4996         };
4997         struct line *diff_hdr;
4998         struct io io = {};
4999         int argc = 3;
5000
5001         diff_hdr = stage_diff_find(view, chunk, LINE_DIFF_HEADER);
5002         if (!diff_hdr)
5003                 return FALSE;
5004
5005         if (!revert)
5006                 apply_argv[argc++] = "--cached";
5007         if (revert || stage_line_type == LINE_STAT_STAGED)
5008                 apply_argv[argc++] = "-R";
5009         apply_argv[argc++] = "-";
5010         apply_argv[argc++] = NULL;
5011         if (!run_io(&io, apply_argv, opt_cdup, IO_WR))
5012                 return FALSE;
5013
5014         if (!stage_diff_write(&io, diff_hdr, chunk) ||
5015             !stage_diff_write(&io, chunk, view->line + view->lines))
5016                 chunk = NULL;
5017
5018         done_io(&io);
5019         run_io_bg(update_index_argv);
5020
5021         return chunk ? TRUE : FALSE;
5022 }
5023
5024 static bool
5025 stage_update(struct view *view, struct line *line)
5026 {
5027         struct line *chunk = NULL;
5028
5029         if (!is_initial_commit() && stage_line_type != LINE_STAT_UNTRACKED)
5030                 chunk = stage_diff_find(view, line, LINE_DIFF_CHUNK);
5031
5032         if (chunk) {
5033                 if (!stage_apply_chunk(view, chunk, FALSE)) {
5034                         report("Failed to apply chunk");
5035                         return FALSE;
5036                 }
5037
5038         } else if (!stage_status.status) {
5039                 view = VIEW(REQ_VIEW_STATUS);
5040
5041                 for (line = view->line; line < view->line + view->lines; line++)
5042                         if (line->type == stage_line_type)
5043                                 break;
5044
5045                 if (!status_update_files(view, line + 1)) {
5046                         report("Failed to update files");
5047                         return FALSE;
5048                 }
5049
5050         } else if (!status_update_file(&stage_status, stage_line_type)) {
5051                 report("Failed to update file");
5052                 return FALSE;
5053         }
5054
5055         return TRUE;
5056 }
5057
5058 static bool
5059 stage_revert(struct view *view, struct line *line)
5060 {
5061         struct line *chunk = NULL;
5062
5063         if (!is_initial_commit() && stage_line_type == LINE_STAT_UNSTAGED)
5064                 chunk = stage_diff_find(view, line, LINE_DIFF_CHUNK);
5065
5066         if (chunk) {
5067                 if (!prompt_yesno("Are you sure you want to revert changes?"))
5068                         return FALSE;
5069
5070                 if (!stage_apply_chunk(view, chunk, TRUE)) {
5071                         report("Failed to revert chunk");
5072                         return FALSE;
5073                 }
5074                 return TRUE;
5075
5076         } else {
5077                 return status_revert(stage_status.status ? &stage_status : NULL,
5078                                      stage_line_type, FALSE);
5079         }
5080 }
5081
5082
5083 static void
5084 stage_next(struct view *view, struct line *line)
5085 {
5086         int i;
5087
5088         if (!stage_chunks) {
5089                 static size_t alloc = 0;
5090                 int *tmp;
5091
5092                 for (line = view->line; line < view->line + view->lines; line++) {
5093                         if (line->type != LINE_DIFF_CHUNK)
5094                                 continue;
5095
5096                         tmp = realloc_items(stage_chunk, &alloc,
5097                                             stage_chunks, sizeof(*tmp));
5098                         if (!tmp) {
5099                                 report("Allocation failure");
5100                                 return;
5101                         }
5102
5103                         stage_chunk = tmp;
5104                         stage_chunk[stage_chunks++] = line - view->line;
5105                 }
5106         }
5107
5108         for (i = 0; i < stage_chunks; i++) {
5109                 if (stage_chunk[i] > view->lineno) {
5110                         do_scroll_view(view, stage_chunk[i] - view->lineno);
5111                         report("Chunk %d of %d", i + 1, stage_chunks);
5112                         return;
5113                 }
5114         }
5115
5116         report("No next chunk found");
5117 }
5118
5119 static enum request
5120 stage_request(struct view *view, enum request request, struct line *line)
5121 {
5122         switch (request) {
5123         case REQ_STATUS_UPDATE:
5124                 if (!stage_update(view, line))
5125                         return REQ_NONE;
5126                 break;
5127
5128         case REQ_STATUS_REVERT:
5129                 if (!stage_revert(view, line))
5130                         return REQ_NONE;
5131                 break;
5132
5133         case REQ_STAGE_NEXT:
5134                 if (stage_line_type == LINE_STAT_UNTRACKED) {
5135                         report("File is untracked; press %s to add",
5136                                get_key(REQ_STATUS_UPDATE));
5137                         return REQ_NONE;
5138                 }
5139                 stage_next(view, line);
5140                 return REQ_NONE;
5141
5142         case REQ_EDIT:
5143                 if (!stage_status.new.name[0])
5144                         return request;
5145                 if (stage_status.status == 'D') {
5146                         report("File has been deleted.");
5147                         return REQ_NONE;
5148                 }
5149
5150                 open_editor(stage_status.status != '?', stage_status.new.name);
5151                 break;
5152
5153         case REQ_REFRESH:
5154                 /* Reload everything ... */
5155                 break;
5156
5157         case REQ_VIEW_BLAME:
5158                 if (stage_status.new.name[0]) {
5159                         string_copy(opt_file, stage_status.new.name);
5160                         opt_ref[0] = 0;
5161                 }
5162                 return request;
5163
5164         case REQ_ENTER:
5165                 return pager_request(view, request, line);
5166
5167         default:
5168                 return request;
5169         }
5170
5171         VIEW(REQ_VIEW_STATUS)->p_restore = TRUE;
5172         open_view(view, REQ_VIEW_STATUS, OPEN_RELOAD | OPEN_NOMAXIMIZE);
5173
5174         /* Check whether the staged entry still exists, and close the
5175          * stage view if it doesn't. */
5176         if (!status_exists(&stage_status, stage_line_type)) {
5177                 status_restore(VIEW(REQ_VIEW_STATUS));
5178                 return REQ_VIEW_CLOSE;
5179         }
5180
5181         if (stage_line_type == LINE_STAT_UNTRACKED) {
5182                 if (!suffixcmp(stage_status.new.name, -1, "/")) {
5183                         report("Cannot display a directory");
5184                         return REQ_NONE;
5185                 }
5186
5187                 if (!prepare_update_file(view, stage_status.new.name)) {
5188                         report("Failed to open file: %s", strerror(errno));
5189                         return REQ_NONE;
5190                 }
5191         }
5192         open_view(view, REQ_VIEW_STAGE, OPEN_REFRESH);
5193
5194         return REQ_NONE;
5195 }
5196
5197 static struct view_ops stage_ops = {
5198         "line",
5199         NULL,
5200         NULL,
5201         pager_read,
5202         pager_draw,
5203         stage_request,
5204         pager_grep,
5205         pager_select,
5206 };
5207
5208
5209 /*
5210  * Revision graph
5211  */
5212
5213 struct commit {
5214         char id[SIZEOF_REV];            /* SHA1 ID. */
5215         char title[128];                /* First line of the commit message. */
5216         char author[75];                /* Author of the commit. */
5217         struct tm time;                 /* Date from the author ident. */
5218         struct ref **refs;              /* Repository references. */
5219         chtype graph[SIZEOF_REVGRAPH];  /* Ancestry chain graphics. */
5220         size_t graph_size;              /* The width of the graph array. */
5221         bool has_parents;               /* Rewritten --parents seen. */
5222 };
5223
5224 /* Size of rev graph with no  "padding" columns */
5225 #define SIZEOF_REVITEMS (SIZEOF_REVGRAPH - (SIZEOF_REVGRAPH / 2))
5226
5227 struct rev_graph {
5228         struct rev_graph *prev, *next, *parents;
5229         char rev[SIZEOF_REVITEMS][SIZEOF_REV];
5230         size_t size;
5231         struct commit *commit;
5232         size_t pos;
5233         unsigned int boundary:1;
5234 };
5235
5236 /* Parents of the commit being visualized. */
5237 static struct rev_graph graph_parents[4];
5238
5239 /* The current stack of revisions on the graph. */
5240 static struct rev_graph graph_stacks[4] = {
5241         { &graph_stacks[3], &graph_stacks[1], &graph_parents[0] },
5242         { &graph_stacks[0], &graph_stacks[2], &graph_parents[1] },
5243         { &graph_stacks[1], &graph_stacks[3], &graph_parents[2] },
5244         { &graph_stacks[2], &graph_stacks[0], &graph_parents[3] },
5245 };
5246
5247 static inline bool
5248 graph_parent_is_merge(struct rev_graph *graph)
5249 {
5250         return graph->parents->size > 1;
5251 }
5252
5253 static inline void
5254 append_to_rev_graph(struct rev_graph *graph, chtype symbol)
5255 {
5256         struct commit *commit = graph->commit;
5257
5258         if (commit->graph_size < ARRAY_SIZE(commit->graph) - 1)
5259                 commit->graph[commit->graph_size++] = symbol;
5260 }
5261
5262 static void
5263 clear_rev_graph(struct rev_graph *graph)
5264 {
5265         graph->boundary = 0;
5266         graph->size = graph->pos = 0;
5267         graph->commit = NULL;
5268         memset(graph->parents, 0, sizeof(*graph->parents));
5269 }
5270
5271 static void
5272 done_rev_graph(struct rev_graph *graph)
5273 {
5274         if (graph_parent_is_merge(graph) &&
5275             graph->pos < graph->size - 1 &&
5276             graph->next->size == graph->size + graph->parents->size - 1) {
5277                 size_t i = graph->pos + graph->parents->size - 1;
5278
5279                 graph->commit->graph_size = i * 2;
5280                 while (i < graph->next->size - 1) {
5281                         append_to_rev_graph(graph, ' ');
5282                         append_to_rev_graph(graph, '\\');
5283                         i++;
5284                 }
5285         }
5286
5287         clear_rev_graph(graph);
5288 }
5289
5290 static void
5291 push_rev_graph(struct rev_graph *graph, const char *parent)
5292 {
5293         int i;
5294
5295         /* "Collapse" duplicate parents lines.
5296          *
5297          * FIXME: This needs to also update update the drawn graph but
5298          * for now it just serves as a method for pruning graph lines. */
5299         for (i = 0; i < graph->size; i++)
5300                 if (!strncmp(graph->rev[i], parent, SIZEOF_REV))
5301                         return;
5302
5303         if (graph->size < SIZEOF_REVITEMS) {
5304                 string_copy_rev(graph->rev[graph->size++], parent);
5305         }
5306 }
5307
5308 static chtype
5309 get_rev_graph_symbol(struct rev_graph *graph)
5310 {
5311         chtype symbol;
5312
5313         if (graph->boundary)
5314                 symbol = REVGRAPH_BOUND;
5315         else if (graph->parents->size == 0)
5316                 symbol = REVGRAPH_INIT;
5317         else if (graph_parent_is_merge(graph))
5318                 symbol = REVGRAPH_MERGE;
5319         else if (graph->pos >= graph->size)
5320                 symbol = REVGRAPH_BRANCH;
5321         else
5322                 symbol = REVGRAPH_COMMIT;
5323
5324         return symbol;
5325 }
5326
5327 static void
5328 draw_rev_graph(struct rev_graph *graph)
5329 {
5330         struct rev_filler {
5331                 chtype separator, line;
5332         };
5333         enum { DEFAULT, RSHARP, RDIAG, LDIAG };
5334         static struct rev_filler fillers[] = {
5335                 { ' ',  '|' },
5336                 { '`',  '.' },
5337                 { '\'', ' ' },
5338                 { '/',  ' ' },
5339         };
5340         chtype symbol = get_rev_graph_symbol(graph);
5341         struct rev_filler *filler;
5342         size_t i;
5343
5344         if (opt_line_graphics)
5345                 fillers[DEFAULT].line = line_graphics[LINE_GRAPHIC_VLINE];
5346
5347         filler = &fillers[DEFAULT];
5348
5349         for (i = 0; i < graph->pos; i++) {
5350                 append_to_rev_graph(graph, filler->line);
5351                 if (graph_parent_is_merge(graph->prev) &&
5352                     graph->prev->pos == i)
5353                         filler = &fillers[RSHARP];
5354
5355                 append_to_rev_graph(graph, filler->separator);
5356         }
5357
5358         /* Place the symbol for this revision. */
5359         append_to_rev_graph(graph, symbol);
5360
5361         if (graph->prev->size > graph->size)
5362                 filler = &fillers[RDIAG];
5363         else
5364                 filler = &fillers[DEFAULT];
5365
5366         i++;
5367
5368         for (; i < graph->size; i++) {
5369                 append_to_rev_graph(graph, filler->separator);
5370                 append_to_rev_graph(graph, filler->line);
5371                 if (graph_parent_is_merge(graph->prev) &&
5372                     i < graph->prev->pos + graph->parents->size)
5373                         filler = &fillers[RSHARP];
5374                 if (graph->prev->size > graph->size)
5375                         filler = &fillers[LDIAG];
5376         }
5377
5378         if (graph->prev->size > graph->size) {
5379                 append_to_rev_graph(graph, filler->separator);
5380                 if (filler->line != ' ')
5381                         append_to_rev_graph(graph, filler->line);
5382         }
5383 }
5384
5385 /* Prepare the next rev graph */
5386 static void
5387 prepare_rev_graph(struct rev_graph *graph)
5388 {
5389         size_t i;
5390
5391         /* First, traverse all lines of revisions up to the active one. */
5392         for (graph->pos = 0; graph->pos < graph->size; graph->pos++) {
5393                 if (!strcmp(graph->rev[graph->pos], graph->commit->id))
5394                         break;
5395
5396                 push_rev_graph(graph->next, graph->rev[graph->pos]);
5397         }
5398
5399         /* Interleave the new revision parent(s). */
5400         for (i = 0; !graph->boundary && i < graph->parents->size; i++)
5401                 push_rev_graph(graph->next, graph->parents->rev[i]);
5402
5403         /* Lastly, put any remaining revisions. */
5404         for (i = graph->pos + 1; i < graph->size; i++)
5405                 push_rev_graph(graph->next, graph->rev[i]);
5406 }
5407
5408 static void
5409 update_rev_graph(struct view *view, struct rev_graph *graph)
5410 {
5411         /* If this is the finalizing update ... */
5412         if (graph->commit)
5413                 prepare_rev_graph(graph);
5414
5415         /* Graph visualization needs a one rev look-ahead,
5416          * so the first update doesn't visualize anything. */
5417         if (!graph->prev->commit)
5418                 return;
5419
5420         if (view->lines > 2)
5421                 view->line[view->lines - 3].dirty = 1;
5422         if (view->lines > 1)
5423                 view->line[view->lines - 2].dirty = 1;
5424         draw_rev_graph(graph->prev);
5425         done_rev_graph(graph->prev->prev);
5426 }
5427
5428
5429 /*
5430  * Main view backend
5431  */
5432
5433 static const char *main_argv[SIZEOF_ARG] = {
5434         "git", "log", "--no-color", "--pretty=raw", "--parents",
5435                       "--topo-order", "%(head)", NULL
5436 };
5437
5438 static bool
5439 main_draw(struct view *view, struct line *line, unsigned int lineno)
5440 {
5441         struct commit *commit = line->data;
5442
5443         if (!*commit->author)
5444                 return FALSE;
5445
5446         if (opt_date && draw_date(view, &commit->time))
5447                 return TRUE;
5448
5449         if (opt_author &&
5450             draw_field(view, LINE_MAIN_AUTHOR, commit->author, opt_author_cols, TRUE))
5451                 return TRUE;
5452
5453         if (opt_rev_graph && commit->graph_size &&
5454             draw_graphic(view, LINE_MAIN_REVGRAPH, commit->graph, commit->graph_size))
5455                 return TRUE;
5456
5457         if (opt_show_refs && commit->refs) {
5458                 size_t i = 0;
5459
5460                 do {
5461                         enum line_type type;
5462
5463                         if (commit->refs[i]->head)
5464                                 type = LINE_MAIN_HEAD;
5465                         else if (commit->refs[i]->ltag)
5466                                 type = LINE_MAIN_LOCAL_TAG;
5467                         else if (commit->refs[i]->tag)
5468                                 type = LINE_MAIN_TAG;
5469                         else if (commit->refs[i]->tracked)
5470                                 type = LINE_MAIN_TRACKED;
5471                         else if (commit->refs[i]->remote)
5472                                 type = LINE_MAIN_REMOTE;
5473                         else
5474                                 type = LINE_MAIN_REF;
5475
5476                         if (draw_text(view, type, "[", TRUE) ||
5477                             draw_text(view, type, commit->refs[i]->name, TRUE) ||
5478                             draw_text(view, type, "]", TRUE))
5479                                 return TRUE;
5480
5481                         if (draw_text(view, LINE_DEFAULT, " ", TRUE))
5482                                 return TRUE;
5483                 } while (commit->refs[i++]->next);
5484         }
5485
5486         draw_text(view, LINE_DEFAULT, commit->title, TRUE);
5487         return TRUE;
5488 }
5489
5490 /* Reads git log --pretty=raw output and parses it into the commit struct. */
5491 static bool
5492 main_read(struct view *view, char *line)
5493 {
5494         static struct rev_graph *graph = graph_stacks;
5495         enum line_type type;
5496         struct commit *commit;
5497
5498         if (!line) {
5499                 int i;
5500
5501                 if (!view->lines && !view->parent)
5502                         die("No revisions match the given arguments.");
5503                 if (view->lines > 0) {
5504                         commit = view->line[view->lines - 1].data;
5505                         view->line[view->lines - 1].dirty = 1;
5506                         if (!*commit->author) {
5507                                 view->lines--;
5508                                 free(commit);
5509                                 graph->commit = NULL;
5510                         }
5511                 }
5512                 update_rev_graph(view, graph);
5513
5514                 for (i = 0; i < ARRAY_SIZE(graph_stacks); i++)
5515                         clear_rev_graph(&graph_stacks[i]);
5516                 return TRUE;
5517         }
5518
5519         type = get_line_type(line);
5520         if (type == LINE_COMMIT) {
5521                 commit = calloc(1, sizeof(struct commit));
5522                 if (!commit)
5523                         return FALSE;
5524
5525                 line += STRING_SIZE("commit ");
5526                 if (*line == '-') {
5527                         graph->boundary = 1;
5528                         line++;
5529                 }
5530
5531                 string_copy_rev(commit->id, line);
5532                 commit->refs = get_refs(commit->id);
5533                 graph->commit = commit;
5534                 add_line_data(view, commit, LINE_MAIN_COMMIT);
5535
5536                 while ((line = strchr(line, ' '))) {
5537                         line++;
5538                         push_rev_graph(graph->parents, line);
5539                         commit->has_parents = TRUE;
5540                 }
5541                 return TRUE;
5542         }
5543
5544         if (!view->lines)
5545                 return TRUE;
5546         commit = view->line[view->lines - 1].data;
5547
5548         switch (type) {
5549         case LINE_PARENT:
5550                 if (commit->has_parents)
5551                         break;
5552                 push_rev_graph(graph->parents, line + STRING_SIZE("parent "));
5553                 break;
5554
5555         case LINE_AUTHOR:
5556         {
5557                 /* Parse author lines where the name may be empty:
5558                  *      author  <email@address.tld> 1138474660 +0100
5559                  */
5560                 char *ident = line + STRING_SIZE("author ");
5561                 char *nameend = strchr(ident, '<');
5562                 char *emailend = strchr(ident, '>');
5563
5564                 if (!nameend || !emailend)
5565                         break;
5566
5567                 update_rev_graph(view, graph);
5568                 graph = graph->next;
5569
5570                 *nameend = *emailend = 0;
5571                 ident = chomp_string(ident);
5572                 if (!*ident) {
5573                         ident = chomp_string(nameend + 1);
5574                         if (!*ident)
5575                                 ident = "Unknown";
5576                 }
5577
5578                 string_ncopy(commit->author, ident, strlen(ident));
5579                 view->line[view->lines - 1].dirty = 1;
5580
5581                 /* Parse epoch and timezone */
5582                 if (emailend[1] == ' ') {
5583                         char *secs = emailend + 2;
5584                         char *zone = strchr(secs, ' ');
5585                         time_t time = (time_t) atol(secs);
5586
5587                         if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
5588                                 long tz;
5589
5590                                 zone++;
5591                                 tz  = ('0' - zone[1]) * 60 * 60 * 10;
5592                                 tz += ('0' - zone[2]) * 60 * 60;
5593                                 tz += ('0' - zone[3]) * 60;
5594                                 tz += ('0' - zone[4]) * 60;
5595
5596                                 if (zone[0] == '-')
5597                                         tz = -tz;
5598
5599                                 time -= tz;
5600                         }
5601
5602                         gmtime_r(&time, &commit->time);
5603                 }
5604                 break;
5605         }
5606         default:
5607                 /* Fill in the commit title if it has not already been set. */
5608                 if (commit->title[0])
5609                         break;
5610
5611                 /* Require titles to start with a non-space character at the
5612                  * offset used by git log. */
5613                 if (strncmp(line, "    ", 4))
5614                         break;
5615                 line += 4;
5616                 /* Well, if the title starts with a whitespace character,
5617                  * try to be forgiving.  Otherwise we end up with no title. */
5618                 while (isspace(*line))
5619                         line++;
5620                 if (*line == '\0')
5621                         break;
5622                 /* FIXME: More graceful handling of titles; append "..." to
5623                  * shortened titles, etc. */
5624
5625                 string_ncopy(commit->title, line, strlen(line));
5626                 view->line[view->lines - 1].dirty = 1;
5627         }
5628
5629         return TRUE;
5630 }
5631
5632 static enum request
5633 main_request(struct view *view, enum request request, struct line *line)
5634 {
5635         enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
5636
5637         switch (request) {
5638         case REQ_ENTER:
5639                 open_view(view, REQ_VIEW_DIFF, flags);
5640                 break;
5641         case REQ_REFRESH:
5642                 load_refs();
5643                 open_view(view, REQ_VIEW_MAIN, OPEN_REFRESH);
5644                 break;
5645         default:
5646                 return request;
5647         }
5648
5649         return REQ_NONE;
5650 }
5651
5652 static bool
5653 grep_refs(struct ref **refs, regex_t *regex)
5654 {
5655         regmatch_t pmatch;
5656         size_t i = 0;
5657
5658         if (!refs)
5659                 return FALSE;
5660         do {
5661                 if (regexec(regex, refs[i]->name, 1, &pmatch, 0) != REG_NOMATCH)
5662                         return TRUE;
5663         } while (refs[i++]->next);
5664
5665         return FALSE;
5666 }
5667
5668 static bool
5669 main_grep(struct view *view, struct line *line)
5670 {
5671         struct commit *commit = line->data;
5672         enum { S_TITLE, S_AUTHOR, S_DATE, S_REFS, S_END } state;
5673         char buf[DATE_COLS + 1];
5674         regmatch_t pmatch;
5675
5676         for (state = S_TITLE; state < S_END; state++) {
5677                 char *text;
5678
5679                 switch (state) {
5680                 case S_TITLE:   text = commit->title;   break;
5681                 case S_AUTHOR:
5682                         if (!opt_author)
5683                                 continue;
5684                         text = commit->author;
5685                         break;
5686                 case S_DATE:
5687                         if (!opt_date)
5688                                 continue;
5689                         if (!strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time))
5690                                 continue;
5691                         text = buf;
5692                         break;
5693                 case S_REFS:
5694                         if (!opt_show_refs)
5695                                 continue;
5696                         if (grep_refs(commit->refs, view->regex) == TRUE)
5697                                 return TRUE;
5698                         continue;
5699                 default:
5700                         return FALSE;
5701                 }
5702
5703                 if (regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
5704                         return TRUE;
5705         }
5706
5707         return FALSE;
5708 }
5709
5710 static void
5711 main_select(struct view *view, struct line *line)
5712 {
5713         struct commit *commit = line->data;
5714
5715         string_copy_rev(view->ref, commit->id);
5716         string_copy_rev(ref_commit, view->ref);
5717 }
5718
5719 static struct view_ops main_ops = {
5720         "commit",
5721         main_argv,
5722         NULL,
5723         main_read,
5724         main_draw,
5725         main_request,
5726         main_grep,
5727         main_select,
5728 };
5729
5730
5731 /*
5732  * Unicode / UTF-8 handling
5733  *
5734  * NOTE: Much of the following code for dealing with unicode is derived from
5735  * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
5736  * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
5737  */
5738
5739 /* I've (over)annotated a lot of code snippets because I am not entirely
5740  * confident that the approach taken by this small UTF-8 interface is correct.
5741  * --jonas */
5742
5743 static inline int
5744 unicode_width(unsigned long c)
5745 {
5746         if (c >= 0x1100 &&
5747            (c <= 0x115f                         /* Hangul Jamo */
5748             || c == 0x2329
5749             || c == 0x232a
5750             || (c >= 0x2e80  && c <= 0xa4cf && c != 0x303f)
5751                                                 /* CJK ... Yi */
5752             || (c >= 0xac00  && c <= 0xd7a3)    /* Hangul Syllables */
5753             || (c >= 0xf900  && c <= 0xfaff)    /* CJK Compatibility Ideographs */
5754             || (c >= 0xfe30  && c <= 0xfe6f)    /* CJK Compatibility Forms */
5755             || (c >= 0xff00  && c <= 0xff60)    /* Fullwidth Forms */
5756             || (c >= 0xffe0  && c <= 0xffe6)
5757             || (c >= 0x20000 && c <= 0x2fffd)
5758             || (c >= 0x30000 && c <= 0x3fffd)))
5759                 return 2;
5760
5761         if (c == '\t')
5762                 return opt_tab_size;
5763
5764         return 1;
5765 }
5766
5767 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
5768  * Illegal bytes are set one. */
5769 static const unsigned char utf8_bytes[256] = {
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         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,
5774         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,
5775         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,
5776         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,
5777         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,
5778 };
5779
5780 /* Decode UTF-8 multi-byte representation into a unicode character. */
5781 static inline unsigned long
5782 utf8_to_unicode(const char *string, size_t length)
5783 {
5784         unsigned long unicode;
5785
5786         switch (length) {
5787         case 1:
5788                 unicode  =   string[0];
5789                 break;
5790         case 2:
5791                 unicode  =  (string[0] & 0x1f) << 6;
5792                 unicode +=  (string[1] & 0x3f);
5793                 break;
5794         case 3:
5795                 unicode  =  (string[0] & 0x0f) << 12;
5796                 unicode += ((string[1] & 0x3f) << 6);
5797                 unicode +=  (string[2] & 0x3f);
5798                 break;
5799         case 4:
5800                 unicode  =  (string[0] & 0x0f) << 18;
5801                 unicode += ((string[1] & 0x3f) << 12);
5802                 unicode += ((string[2] & 0x3f) << 6);
5803                 unicode +=  (string[3] & 0x3f);
5804                 break;
5805         case 5:
5806                 unicode  =  (string[0] & 0x0f) << 24;
5807                 unicode += ((string[1] & 0x3f) << 18);
5808                 unicode += ((string[2] & 0x3f) << 12);
5809                 unicode += ((string[3] & 0x3f) << 6);
5810                 unicode +=  (string[4] & 0x3f);
5811                 break;
5812         case 6:
5813                 unicode  =  (string[0] & 0x01) << 30;
5814                 unicode += ((string[1] & 0x3f) << 24);
5815                 unicode += ((string[2] & 0x3f) << 18);
5816                 unicode += ((string[3] & 0x3f) << 12);
5817                 unicode += ((string[4] & 0x3f) << 6);
5818                 unicode +=  (string[5] & 0x3f);
5819                 break;
5820         default:
5821                 die("Invalid unicode length");
5822         }
5823
5824         /* Invalid characters could return the special 0xfffd value but NUL
5825          * should be just as good. */
5826         return unicode > 0xffff ? 0 : unicode;
5827 }
5828
5829 /* Calculates how much of string can be shown within the given maximum width
5830  * and sets trimmed parameter to non-zero value if all of string could not be
5831  * shown. If the reserve flag is TRUE, it will reserve at least one
5832  * trailing character, which can be useful when drawing a delimiter.
5833  *
5834  * Returns the number of bytes to output from string to satisfy max_width. */
5835 static size_t
5836 utf8_length(const char *string, int *width, size_t max_width, int *trimmed, bool reserve)
5837 {
5838         const char *start = string;
5839         const char *end = strchr(string, '\0');
5840         unsigned char last_bytes = 0;
5841         size_t last_ucwidth = 0;
5842
5843         *width = 0;
5844         *trimmed = 0;
5845
5846         while (string < end) {
5847                 int c = *(unsigned char *) string;
5848                 unsigned char bytes = utf8_bytes[c];
5849                 size_t ucwidth;
5850                 unsigned long unicode;
5851
5852                 if (string + bytes > end)
5853                         break;
5854
5855                 /* Change representation to figure out whether
5856                  * it is a single- or double-width character. */
5857
5858                 unicode = utf8_to_unicode(string, bytes);
5859                 /* FIXME: Graceful handling of invalid unicode character. */
5860                 if (!unicode)
5861                         break;
5862
5863                 ucwidth = unicode_width(unicode);
5864                 *width  += ucwidth;
5865                 if (*width > max_width) {
5866                         *trimmed = 1;
5867                         *width -= ucwidth;
5868                         if (reserve && *width == max_width) {
5869                                 string -= last_bytes;
5870                                 *width -= last_ucwidth;
5871                         }
5872                         break;
5873                 }
5874
5875                 string  += bytes;
5876                 last_bytes = bytes;
5877                 last_ucwidth = ucwidth;
5878         }
5879
5880         return string - start;
5881 }
5882
5883
5884 /*
5885  * Status management
5886  */
5887
5888 /* Whether or not the curses interface has been initialized. */
5889 static bool cursed = FALSE;
5890
5891 /* The status window is used for polling keystrokes. */
5892 static WINDOW *status_win;
5893
5894 static bool status_empty = TRUE;
5895
5896 /* Update status and title window. */
5897 static void
5898 report(const char *msg, ...)
5899 {
5900         struct view *view = display[current_view];
5901
5902         if (input_mode)
5903                 return;
5904
5905         if (!view) {
5906                 char buf[SIZEOF_STR];
5907                 va_list args;
5908
5909                 va_start(args, msg);
5910                 if (vsnprintf(buf, sizeof(buf), msg, args) >= sizeof(buf)) {
5911                         buf[sizeof(buf) - 1] = 0;
5912                         buf[sizeof(buf) - 2] = '.';
5913                         buf[sizeof(buf) - 3] = '.';
5914                         buf[sizeof(buf) - 4] = '.';
5915                 }
5916                 va_end(args);
5917                 die("%s", buf);
5918         }
5919
5920         if (!status_empty || *msg) {
5921                 va_list args;
5922
5923                 va_start(args, msg);
5924
5925                 wmove(status_win, 0, 0);
5926                 if (*msg) {
5927                         vwprintw(status_win, msg, args);
5928                         status_empty = FALSE;
5929                 } else {
5930                         status_empty = TRUE;
5931                 }
5932                 wclrtoeol(status_win);
5933                 wrefresh(status_win);
5934
5935                 va_end(args);
5936         }
5937
5938         update_view_title(view);
5939         update_display_cursor(view);
5940 }
5941
5942 /* Controls when nodelay should be in effect when polling user input. */
5943 static void
5944 set_nonblocking_input(bool loading)
5945 {
5946         static unsigned int loading_views;
5947
5948         if ((loading == FALSE && loading_views-- == 1) ||
5949             (loading == TRUE  && loading_views++ == 0))
5950                 nodelay(status_win, loading);
5951 }
5952
5953 static void
5954 init_display(void)
5955 {
5956         int x, y;
5957
5958         /* Initialize the curses library */
5959         if (isatty(STDIN_FILENO)) {
5960                 cursed = !!initscr();
5961                 opt_tty = stdin;
5962         } else {
5963                 /* Leave stdin and stdout alone when acting as a pager. */
5964                 opt_tty = fopen("/dev/tty", "r+");
5965                 if (!opt_tty)
5966                         die("Failed to open /dev/tty");
5967                 cursed = !!newterm(NULL, opt_tty, opt_tty);
5968         }
5969
5970         if (!cursed)
5971                 die("Failed to initialize curses");
5972
5973         nonl();         /* Tell curses not to do NL->CR/NL on output */
5974         cbreak();       /* Take input chars one at a time, no wait for \n */
5975         noecho();       /* Don't echo input */
5976         leaveok(stdscr, TRUE);
5977
5978         if (has_colors())
5979                 init_colors();
5980
5981         getmaxyx(stdscr, y, x);
5982         status_win = newwin(1, 0, y - 1, 0);
5983         if (!status_win)
5984                 die("Failed to create status window");
5985
5986         /* Enable keyboard mapping */
5987         keypad(status_win, TRUE);
5988         wbkgdset(status_win, get_line_attr(LINE_STATUS));
5989
5990         TABSIZE = opt_tab_size;
5991         if (opt_line_graphics) {
5992                 line_graphics[LINE_GRAPHIC_VLINE] = ACS_VLINE;
5993         }
5994 }
5995
5996 static int
5997 get_input(bool prompting)
5998 {
5999         struct view *view;
6000         int i, key;
6001
6002         if (prompting)
6003                 input_mode = TRUE;
6004
6005         while (true) {
6006                 foreach_view (view, i)
6007                         update_view(view);
6008
6009                 /* Refresh, accept single keystroke of input */
6010                 key = wgetch(status_win);
6011
6012                 /* wgetch() with nodelay() enabled returns ERR when
6013                  * there's no input. */
6014                 if (key == ERR) {
6015                         doupdate();
6016
6017                 } else if (key == KEY_RESIZE) {
6018                         int height, width;
6019
6020                         getmaxyx(stdscr, height, width);
6021
6022                         /* Resize the status view and let the view driver take
6023                          * care of resizing the displayed views. */
6024                         resize_display();
6025                         redraw_display(TRUE);
6026                         wresize(status_win, 1, width);
6027                         mvwin(status_win, height - 1, 0);
6028                         wrefresh(status_win);
6029
6030                 } else {
6031                         input_mode = FALSE;
6032                         return key;
6033                 }
6034         }
6035 }
6036
6037 static bool
6038 prompt_yesno(const char *prompt)
6039 {
6040         enum { WAIT, STOP, CANCEL  } status = WAIT;
6041         bool answer = FALSE;
6042
6043         while (status == WAIT) {
6044                 int key;
6045
6046                 mvwprintw(status_win, 0, 0, "%s [Yy]/[Nn]", prompt);
6047                 wclrtoeol(status_win);
6048
6049                 key = get_input(TRUE);
6050                 switch (key) {
6051                 case 'y':
6052                 case 'Y':
6053                         answer = TRUE;
6054                         status = STOP;
6055                         break;
6056
6057                 case KEY_ESC:
6058                 case KEY_RETURN:
6059                 case KEY_ENTER:
6060                 case KEY_BACKSPACE:
6061                 case 'n':
6062                 case 'N':
6063                 case '\n':
6064                 default:
6065                         answer = FALSE;
6066                         status = CANCEL;
6067                 }
6068         }
6069
6070         /* Clear the status window */
6071         status_empty = FALSE;
6072         report("");
6073
6074         return answer;
6075 }
6076
6077 static char *
6078 read_prompt(const char *prompt)
6079 {
6080         enum { READING, STOP, CANCEL } status = READING;
6081         static char buf[SIZEOF_STR];
6082         int pos = 0;
6083
6084         while (status == READING) {
6085                 int key;
6086
6087                 mvwprintw(status_win, 0, 0, "%s%.*s", prompt, pos, buf);
6088                 wclrtoeol(status_win);
6089
6090                 key = get_input(TRUE);
6091                 switch (key) {
6092                 case KEY_RETURN:
6093                 case KEY_ENTER:
6094                 case '\n':
6095                         status = pos ? STOP : CANCEL;
6096                         break;
6097
6098                 case KEY_BACKSPACE:
6099                         if (pos > 0)
6100                                 pos--;
6101                         else
6102                                 status = CANCEL;
6103                         break;
6104
6105                 case KEY_ESC:
6106                         status = CANCEL;
6107                         break;
6108
6109                 default:
6110                         if (pos >= sizeof(buf)) {
6111                                 report("Input string too long");
6112                                 return NULL;
6113                         }
6114
6115                         if (isprint(key))
6116                                 buf[pos++] = (char) key;
6117                 }
6118         }
6119
6120         /* Clear the status window */
6121         status_empty = FALSE;
6122         report("");
6123
6124         if (status == CANCEL)
6125                 return NULL;
6126
6127         buf[pos++] = 0;
6128
6129         return buf;
6130 }
6131
6132 /*
6133  * Repository properties
6134  */
6135
6136 static int
6137 git_properties(const char **argv, const char *separators,
6138                int (*read_property)(char *, size_t, char *, size_t))
6139 {
6140         struct io io = {};
6141
6142         if (init_io_rd(&io, argv, NULL, FORMAT_NONE))
6143                 return read_properties(&io, separators, read_property);
6144         return ERR;
6145 }
6146
6147 static struct ref *refs = NULL;
6148 static size_t refs_alloc = 0;
6149 static size_t refs_size = 0;
6150
6151 /* Id <-> ref store */
6152 static struct ref ***id_refs = NULL;
6153 static size_t id_refs_alloc = 0;
6154 static size_t id_refs_size = 0;
6155
6156 static int
6157 compare_refs(const void *ref1_, const void *ref2_)
6158 {
6159         const struct ref *ref1 = *(const struct ref **)ref1_;
6160         const struct ref *ref2 = *(const struct ref **)ref2_;
6161
6162         if (ref1->tag != ref2->tag)
6163                 return ref2->tag - ref1->tag;
6164         if (ref1->ltag != ref2->ltag)
6165                 return ref2->ltag - ref2->ltag;
6166         if (ref1->head != ref2->head)
6167                 return ref2->head - ref1->head;
6168         if (ref1->tracked != ref2->tracked)
6169                 return ref2->tracked - ref1->tracked;
6170         if (ref1->remote != ref2->remote)
6171                 return ref2->remote - ref1->remote;
6172         return strcmp(ref1->name, ref2->name);
6173 }
6174
6175 static struct ref **
6176 get_refs(const char *id)
6177 {
6178         struct ref ***tmp_id_refs;
6179         struct ref **ref_list = NULL;
6180         size_t ref_list_alloc = 0;
6181         size_t ref_list_size = 0;
6182         size_t i;
6183
6184         for (i = 0; i < id_refs_size; i++)
6185                 if (!strcmp(id, id_refs[i][0]->id))
6186                         return id_refs[i];
6187
6188         tmp_id_refs = realloc_items(id_refs, &id_refs_alloc, id_refs_size + 1,
6189                                     sizeof(*id_refs));
6190         if (!tmp_id_refs)
6191                 return NULL;
6192
6193         id_refs = tmp_id_refs;
6194
6195         for (i = 0; i < refs_size; i++) {
6196                 struct ref **tmp;
6197
6198                 if (strcmp(id, refs[i].id))
6199                         continue;
6200
6201                 tmp = realloc_items(ref_list, &ref_list_alloc,
6202                                     ref_list_size + 1, sizeof(*ref_list));
6203                 if (!tmp) {
6204                         if (ref_list)
6205                                 free(ref_list);
6206                         return NULL;
6207                 }
6208
6209                 ref_list = tmp;
6210                 ref_list[ref_list_size] = &refs[i];
6211                 /* XXX: The properties of the commit chains ensures that we can
6212                  * safely modify the shared ref. The repo references will
6213                  * always be similar for the same id. */
6214                 ref_list[ref_list_size]->next = 1;
6215
6216                 ref_list_size++;
6217         }
6218
6219         if (ref_list) {
6220                 qsort(ref_list, ref_list_size, sizeof(*ref_list), compare_refs);
6221                 ref_list[ref_list_size - 1]->next = 0;
6222                 id_refs[id_refs_size++] = ref_list;
6223         }
6224
6225         return ref_list;
6226 }
6227
6228 static int
6229 read_ref(char *id, size_t idlen, char *name, size_t namelen)
6230 {
6231         struct ref *ref;
6232         bool tag = FALSE;
6233         bool ltag = FALSE;
6234         bool remote = FALSE;
6235         bool tracked = FALSE;
6236         bool check_replace = FALSE;
6237         bool head = FALSE;
6238
6239         if (!prefixcmp(name, "refs/tags/")) {
6240                 if (!suffixcmp(name, namelen, "^{}")) {
6241                         namelen -= 3;
6242                         name[namelen] = 0;
6243                         if (refs_size > 0 && refs[refs_size - 1].ltag == TRUE)
6244                                 check_replace = TRUE;
6245                 } else {
6246                         ltag = TRUE;
6247                 }
6248
6249                 tag = TRUE;
6250                 namelen -= STRING_SIZE("refs/tags/");
6251                 name    += STRING_SIZE("refs/tags/");
6252
6253         } else if (!prefixcmp(name, "refs/remotes/")) {
6254                 remote = TRUE;
6255                 namelen -= STRING_SIZE("refs/remotes/");
6256                 name    += STRING_SIZE("refs/remotes/");
6257                 tracked  = !strcmp(opt_remote, name);
6258
6259         } else if (!prefixcmp(name, "refs/heads/")) {
6260                 namelen -= STRING_SIZE("refs/heads/");
6261                 name    += STRING_SIZE("refs/heads/");
6262                 head     = !strncmp(opt_head, name, namelen);
6263
6264         } else if (!strcmp(name, "HEAD")) {
6265                 string_ncopy(opt_head_rev, id, idlen);
6266                 return OK;
6267         }
6268
6269         if (check_replace && !strcmp(name, refs[refs_size - 1].name)) {
6270                 /* it's an annotated tag, replace the previous sha1 with the
6271                  * resolved commit id; relies on the fact git-ls-remote lists
6272                  * the commit id of an annotated tag right before the commit id
6273                  * it points to. */
6274                 refs[refs_size - 1].ltag = ltag;
6275                 string_copy_rev(refs[refs_size - 1].id, id);
6276
6277                 return OK;
6278         }
6279         refs = realloc_items(refs, &refs_alloc, refs_size + 1, sizeof(*refs));
6280         if (!refs)
6281                 return ERR;
6282
6283         ref = &refs[refs_size++];
6284         ref->name = malloc(namelen + 1);
6285         if (!ref->name)
6286                 return ERR;
6287
6288         strncpy(ref->name, name, namelen);
6289         ref->name[namelen] = 0;
6290         ref->head = head;
6291         ref->tag = tag;
6292         ref->ltag = ltag;
6293         ref->remote = remote;
6294         ref->tracked = tracked;
6295         string_copy_rev(ref->id, id);
6296
6297         return OK;
6298 }
6299
6300 static int
6301 load_refs(void)
6302 {
6303         static const char *ls_remote_argv[SIZEOF_ARG] = {
6304                 "git", "ls-remote", ".", NULL
6305         };
6306         static bool init = FALSE;
6307
6308         if (!init) {
6309                 argv_from_env(ls_remote_argv, "TIG_LS_REMOTE");
6310                 init = TRUE;
6311         }
6312
6313         if (!*opt_git_dir)
6314                 return OK;
6315
6316         while (refs_size > 0)
6317                 free(refs[--refs_size].name);
6318         while (id_refs_size > 0)
6319                 free(id_refs[--id_refs_size]);
6320
6321         return git_properties(ls_remote_argv, "\t", read_ref);
6322 }
6323
6324 static int
6325 read_repo_config_option(char *name, size_t namelen, char *value, size_t valuelen)
6326 {
6327         if (!strcmp(name, "i18n.commitencoding"))
6328                 string_ncopy(opt_encoding, value, valuelen);
6329
6330         if (!strcmp(name, "core.editor"))
6331                 string_ncopy(opt_editor, value, valuelen);
6332
6333         /* branch.<head>.remote */
6334         if (*opt_head &&
6335             !strncmp(name, "branch.", 7) &&
6336             !strncmp(name + 7, opt_head, strlen(opt_head)) &&
6337             !strcmp(name + 7 + strlen(opt_head), ".remote"))
6338                 string_ncopy(opt_remote, value, valuelen);
6339
6340         if (*opt_head && *opt_remote &&
6341             !strncmp(name, "branch.", 7) &&
6342             !strncmp(name + 7, opt_head, strlen(opt_head)) &&
6343             !strcmp(name + 7 + strlen(opt_head), ".merge")) {
6344                 size_t from = strlen(opt_remote);
6345
6346                 if (!prefixcmp(value, "refs/heads/")) {
6347                         value += STRING_SIZE("refs/heads/");
6348                         valuelen -= STRING_SIZE("refs/heads/");
6349                 }
6350
6351                 if (!string_format_from(opt_remote, &from, "/%s", value))
6352                         opt_remote[0] = 0;
6353         }
6354
6355         return OK;
6356 }
6357
6358 static int
6359 load_git_config(void)
6360 {
6361         const char *config_list_argv[] = { "git", GIT_CONFIG, "--list", NULL };
6362
6363         return git_properties(config_list_argv, "=", read_repo_config_option);
6364 }
6365
6366 static int
6367 read_repo_info(char *name, size_t namelen, char *value, size_t valuelen)
6368 {
6369         if (!opt_git_dir[0]) {
6370                 string_ncopy(opt_git_dir, name, namelen);
6371
6372         } else if (opt_is_inside_work_tree == -1) {
6373                 /* This can be 3 different values depending on the
6374                  * version of git being used. If git-rev-parse does not
6375                  * understand --is-inside-work-tree it will simply echo
6376                  * the option else either "true" or "false" is printed.
6377                  * Default to true for the unknown case. */
6378                 opt_is_inside_work_tree = strcmp(name, "false") ? TRUE : FALSE;
6379         } else {
6380                 string_ncopy(opt_cdup, name, namelen);
6381         }
6382
6383         return OK;
6384 }
6385
6386 static int
6387 load_repo_info(void)
6388 {
6389         const char *head_argv[] = {
6390                 "git", "symbolic-ref", "HEAD", NULL
6391         };
6392         const char *rev_parse_argv[] = {
6393                 "git", "rev-parse", "--git-dir", "--is-inside-work-tree",
6394                         "--show-cdup", NULL
6395         };
6396
6397         if (run_io_buf(head_argv, opt_head, sizeof(opt_head))) {
6398                 chomp_string(opt_head);
6399                 if (!prefixcmp(opt_head, "refs/heads/")) {
6400                         char *offset = opt_head + STRING_SIZE("refs/heads/");
6401
6402                         memmove(opt_head, offset, strlen(offset) + 1);
6403                 }
6404         }
6405
6406         return git_properties(rev_parse_argv, "=", read_repo_info);
6407 }
6408
6409 static int
6410 read_properties(struct io *io, const char *separators,
6411                 int (*read_property)(char *, size_t, char *, size_t))
6412 {
6413         char *name;
6414         int state = OK;
6415
6416         if (!start_io(io))
6417                 return ERR;
6418
6419         while (state == OK && (name = io_get(io, '\n', TRUE))) {
6420                 char *value;
6421                 size_t namelen;
6422                 size_t valuelen;
6423
6424                 name = chomp_string(name);
6425                 namelen = strcspn(name, separators);
6426
6427                 if (name[namelen]) {
6428                         name[namelen] = 0;
6429                         value = chomp_string(name + namelen + 1);
6430                         valuelen = strlen(value);
6431
6432                 } else {
6433                         value = "";
6434                         valuelen = 0;
6435                 }
6436
6437                 state = read_property(name, namelen, value, valuelen);
6438         }
6439
6440         if (state != ERR && io_error(io))
6441                 state = ERR;
6442         done_io(io);
6443
6444         return state;
6445 }
6446
6447
6448 /*
6449  * Main
6450  */
6451
6452 static void __NORETURN
6453 quit(int sig)
6454 {
6455         /* XXX: Restore tty modes and let the OS cleanup the rest! */
6456         if (cursed)
6457                 endwin();
6458         exit(0);
6459 }
6460
6461 static void __NORETURN
6462 die(const char *err, ...)
6463 {
6464         va_list args;
6465
6466         endwin();
6467
6468         va_start(args, err);
6469         fputs("tig: ", stderr);
6470         vfprintf(stderr, err, args);
6471         fputs("\n", stderr);
6472         va_end(args);
6473
6474         exit(1);
6475 }
6476
6477 static void
6478 warn(const char *msg, ...)
6479 {
6480         va_list args;
6481
6482         va_start(args, msg);
6483         fputs("tig warning: ", stderr);
6484         vfprintf(stderr, msg, args);
6485         fputs("\n", stderr);
6486         va_end(args);
6487 }
6488
6489 int
6490 main(int argc, const char *argv[])
6491 {
6492         const char **run_argv = NULL;
6493         struct view *view;
6494         enum request request;
6495         size_t i;
6496
6497         signal(SIGINT, quit);
6498
6499         if (setlocale(LC_ALL, "")) {
6500                 char *codeset = nl_langinfo(CODESET);
6501
6502                 string_ncopy(opt_codeset, codeset, strlen(codeset));
6503         }
6504
6505         if (load_repo_info() == ERR)
6506                 die("Failed to load repo info.");
6507
6508         if (load_options() == ERR)
6509                 die("Failed to load user config.");
6510
6511         if (load_git_config() == ERR)
6512                 die("Failed to load repo config.");
6513
6514         request = parse_options(argc, argv, &run_argv);
6515         if (request == REQ_NONE)
6516                 return 0;
6517
6518         /* Require a git repository unless when running in pager mode. */
6519         if (!opt_git_dir[0] && request != REQ_VIEW_PAGER)
6520                 die("Not a git repository");
6521
6522         if (*opt_encoding && strcasecmp(opt_encoding, "UTF-8"))
6523                 opt_utf8 = FALSE;
6524
6525         if (*opt_codeset && strcmp(opt_codeset, opt_encoding)) {
6526                 opt_iconv = iconv_open(opt_codeset, opt_encoding);
6527                 if (opt_iconv == ICONV_NONE)
6528                         die("Failed to initialize character set conversion");
6529         }
6530
6531         if (load_refs() == ERR)
6532                 die("Failed to load refs.");
6533
6534         foreach_view (view, i)
6535                 argv_from_env(view->ops->argv, view->cmd_env);
6536
6537         init_display();
6538
6539         if (request == REQ_VIEW_PAGER || run_argv) {
6540                 if (request == REQ_VIEW_PAGER)
6541                         io_open(&VIEW(request)->io, "");
6542                 else if (!prepare_update(VIEW(request), run_argv, NULL, FORMAT_NONE))
6543                         die("Failed to format arguments");
6544                 open_view(NULL, request, OPEN_PREPARED);
6545                 request = REQ_NONE;
6546         }
6547
6548         while (view_driver(display[current_view], request)) {
6549                 int key = get_input(FALSE);
6550
6551                 view = display[current_view];
6552                 request = get_keybinding(view->keymap, key);
6553
6554                 /* Some low-level request handling. This keeps access to
6555                  * status_win restricted. */
6556                 switch (request) {
6557                 case REQ_PROMPT:
6558                 {
6559                         char *cmd = read_prompt(":");
6560
6561                         if (cmd) {
6562                                 struct view *next = VIEW(REQ_VIEW_PAGER);
6563                                 const char *argv[SIZEOF_ARG] = { "git" };
6564                                 int argc = 1;
6565
6566                                 /* When running random commands, initially show the
6567                                  * command in the title. However, it maybe later be
6568                                  * overwritten if a commit line is selected. */
6569                                 string_ncopy(next->ref, cmd, strlen(cmd));
6570
6571                                 if (!argv_from_string(argv, &argc, cmd)) {
6572                                         report("Too many arguments");
6573                                 } else if (!prepare_update(next, argv, NULL, FORMAT_DASH)) {
6574                                         report("Failed to format command");
6575                                 } else {
6576                                         open_view(view, REQ_VIEW_PAGER, OPEN_PREPARED);
6577                                 }
6578                         }
6579
6580                         request = REQ_NONE;
6581                         break;
6582                 }
6583                 case REQ_SEARCH:
6584                 case REQ_SEARCH_BACK:
6585                 {
6586                         const char *prompt = request == REQ_SEARCH ? "/" : "?";
6587                         char *search = read_prompt(prompt);
6588
6589                         if (search)
6590                                 string_ncopy(opt_search, search, strlen(search));
6591                         else
6592                                 request = REQ_NONE;
6593                         break;
6594                 }
6595                 default:
6596                         break;
6597                 }
6598         }
6599
6600         quit(0);
6601
6602         return 0;
6603 }