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