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_BACKGROUNDED = 2,  /* Backgrounded. */
2927         OPEN_RELOAD = 4,        /* Reload view even if it is the current. */
2928         OPEN_NOMAXIMIZE = 8,    /* Do not maximize the current view. */
2929         OPEN_REFRESH = 16,      /* Refresh view using previous command. */
2930         OPEN_PREPARED = 32,     /* Open already prepared command. */
2931 };
2932
2933 static void
2934 open_view(struct view *prev, enum request request, enum open_flags flags)
2935 {
2936         bool backgrounded = !!(flags & OPEN_BACKGROUNDED);
2937         bool split = !!(flags & OPEN_SPLIT);
2938         bool reload = !!(flags & (OPEN_RELOAD | OPEN_REFRESH | OPEN_PREPARED));
2939         bool nomaximize = !!(flags & (OPEN_NOMAXIMIZE | OPEN_REFRESH));
2940         struct view *view = VIEW(request);
2941         int nviews = displayed_views();
2942         struct view *base_view = display[0];
2943
2944         if (view == prev && nviews == 1 && !reload) {
2945                 report("Already in %s view", view->name);
2946                 return;
2947         }
2948
2949         if (view->git_dir && !opt_git_dir[0]) {
2950                 report("The %s view is disabled in pager view", view->name);
2951                 return;
2952         }
2953
2954         if (split) {
2955                 display[1] = view;
2956                 if (!backgrounded)
2957                         current_view = 1;
2958         } else if (!nomaximize) {
2959                 /* Maximize the current view. */
2960                 memset(display, 0, sizeof(display));
2961                 current_view = 0;
2962                 display[current_view] = view;
2963         }
2964
2965         /* Resize the view when switching between split- and full-screen,
2966          * or when switching between two different full-screen views. */
2967         if (nviews != displayed_views() ||
2968             (nviews == 1 && base_view != display[0]))
2969                 resize_display();
2970
2971         if (view->ops->open) {
2972                 if (view->pipe)
2973                         end_update(view, TRUE);
2974                 if (!view->ops->open(view)) {
2975                         report("Failed to load %s view", view->name);
2976                         return;
2977                 }
2978                 restore_view_position(view);
2979
2980         } else if ((reload || strcmp(view->vid, view->id)) &&
2981                    !begin_update(view, flags & (OPEN_REFRESH | OPEN_PREPARED))) {
2982                 report("Failed to load %s view", view->name);
2983                 return;
2984         }
2985
2986         if (split && prev->lineno - prev->offset >= prev->height) {
2987                 /* Take the title line into account. */
2988                 int lines = prev->lineno - prev->offset - prev->height + 1;
2989
2990                 /* Scroll the view that was split if the current line is
2991                  * outside the new limited view. */
2992                 do_scroll_view(prev, lines);
2993         }
2994
2995         if (prev && view != prev) {
2996                 if (split && !backgrounded) {
2997                         /* "Blur" the previous view. */
2998                         update_view_title(prev);
2999                 }
3000
3001                 view->parent = prev;
3002         }
3003
3004         if (view->pipe && view->lines == 0) {
3005                 /* Clear the old view and let the incremental updating refill
3006                  * the screen. */
3007                 werase(view->win);
3008                 view->p_restore = flags & (OPEN_RELOAD | OPEN_REFRESH);
3009                 report("");
3010         } else if (view_is_displayed(view)) {
3011                 redraw_view(view);
3012                 report("");
3013         }
3014
3015         /* If the view is backgrounded the above calls to report()
3016          * won't redraw the view title. */
3017         if (backgrounded)
3018                 update_view_title(view);
3019 }
3020
3021 static void
3022 open_external_viewer(const char *argv[], const char *dir)
3023 {
3024         def_prog_mode();           /* save current tty modes */
3025         endwin();                  /* restore original tty modes */
3026         run_io_fg(argv, dir);
3027         fprintf(stderr, "Press Enter to continue");
3028         getc(opt_tty);
3029         reset_prog_mode();
3030         redraw_display(TRUE);
3031 }
3032
3033 static void
3034 open_mergetool(const char *file)
3035 {
3036         const char *mergetool_argv[] = { "git", "mergetool", file, NULL };
3037
3038         open_external_viewer(mergetool_argv, opt_cdup);
3039 }
3040
3041 static void
3042 open_editor(bool from_root, const char *file)
3043 {
3044         const char *editor_argv[] = { "vi", file, NULL };
3045         const char *editor;
3046
3047         editor = getenv("GIT_EDITOR");
3048         if (!editor && *opt_editor)
3049                 editor = opt_editor;
3050         if (!editor)
3051                 editor = getenv("VISUAL");
3052         if (!editor)
3053                 editor = getenv("EDITOR");
3054         if (!editor)
3055                 editor = "vi";
3056
3057         editor_argv[0] = editor;
3058         open_external_viewer(editor_argv, from_root ? opt_cdup : NULL);
3059 }
3060
3061 static void
3062 open_run_request(enum request request)
3063 {
3064         struct run_request *req = get_run_request(request);
3065         const char *argv[ARRAY_SIZE(req->argv)] = { NULL };
3066
3067         if (!req) {
3068                 report("Unknown run request");
3069                 return;
3070         }
3071
3072         if (format_argv(argv, req->argv, FORMAT_ALL))
3073                 open_external_viewer(argv, NULL);
3074         free_argv(argv);
3075 }
3076
3077 /*
3078  * User request switch noodle
3079  */
3080
3081 static int
3082 view_driver(struct view *view, enum request request)
3083 {
3084         int i;
3085
3086         if (request == REQ_NONE) {
3087                 doupdate();
3088                 return TRUE;
3089         }
3090
3091         if (request > REQ_NONE) {
3092                 open_run_request(request);
3093                 /* FIXME: When all views can refresh always do this. */
3094                 if (view == VIEW(REQ_VIEW_STATUS) ||
3095                     view == VIEW(REQ_VIEW_MAIN) ||
3096                     view == VIEW(REQ_VIEW_LOG) ||
3097                     view == VIEW(REQ_VIEW_STAGE))
3098                         request = REQ_REFRESH;
3099                 else
3100                         return TRUE;
3101         }
3102
3103         if (view && view->lines) {
3104                 request = view->ops->request(view, request, &view->line[view->lineno]);
3105                 if (request == REQ_NONE)
3106                         return TRUE;
3107         }
3108
3109         switch (request) {
3110         case REQ_MOVE_UP:
3111         case REQ_MOVE_DOWN:
3112         case REQ_MOVE_PAGE_UP:
3113         case REQ_MOVE_PAGE_DOWN:
3114         case REQ_MOVE_FIRST_LINE:
3115         case REQ_MOVE_LAST_LINE:
3116                 move_view(view, request);
3117                 break;
3118
3119         case REQ_SCROLL_LEFT:
3120         case REQ_SCROLL_RIGHT:
3121         case REQ_SCROLL_LINE_DOWN:
3122         case REQ_SCROLL_LINE_UP:
3123         case REQ_SCROLL_PAGE_DOWN:
3124         case REQ_SCROLL_PAGE_UP:
3125                 scroll_view(view, request);
3126                 break;
3127
3128         case REQ_VIEW_BLAME:
3129                 if (!opt_file[0]) {
3130                         report("No file chosen, press %s to open tree view",
3131                                get_key(REQ_VIEW_TREE));
3132                         break;
3133                 }
3134                 open_view(view, request, OPEN_DEFAULT);
3135                 break;
3136
3137         case REQ_VIEW_BLOB:
3138                 if (!ref_blob[0]) {
3139                         report("No file chosen, press %s to open tree view",
3140                                get_key(REQ_VIEW_TREE));
3141                         break;
3142                 }
3143                 open_view(view, request, OPEN_DEFAULT);
3144                 break;
3145
3146         case REQ_VIEW_PAGER:
3147                 if (!VIEW(REQ_VIEW_PAGER)->pipe && !VIEW(REQ_VIEW_PAGER)->lines) {
3148                         report("No pager content, press %s to run command from prompt",
3149                                get_key(REQ_PROMPT));
3150                         break;
3151                 }
3152                 open_view(view, request, OPEN_DEFAULT);
3153                 break;
3154
3155         case REQ_VIEW_STAGE:
3156                 if (!VIEW(REQ_VIEW_STAGE)->lines) {
3157                         report("No stage content, press %s to open the status view and choose file",
3158                                get_key(REQ_VIEW_STATUS));
3159                         break;
3160                 }
3161                 open_view(view, request, OPEN_DEFAULT);
3162                 break;
3163
3164         case REQ_VIEW_STATUS:
3165                 if (opt_is_inside_work_tree == FALSE) {
3166                         report("The status view requires a working tree");
3167                         break;
3168                 }
3169                 open_view(view, request, OPEN_DEFAULT);
3170                 break;
3171
3172         case REQ_VIEW_MAIN:
3173         case REQ_VIEW_DIFF:
3174         case REQ_VIEW_LOG:
3175         case REQ_VIEW_TREE:
3176         case REQ_VIEW_HELP:
3177                 open_view(view, request, OPEN_DEFAULT);
3178                 break;
3179
3180         case REQ_NEXT:
3181         case REQ_PREVIOUS:
3182                 request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
3183
3184                 if ((view == VIEW(REQ_VIEW_DIFF) &&
3185                      view->parent == VIEW(REQ_VIEW_MAIN)) ||
3186                    (view == VIEW(REQ_VIEW_DIFF) &&
3187                      view->parent == VIEW(REQ_VIEW_BLAME)) ||
3188                    (view == VIEW(REQ_VIEW_STAGE) &&
3189                      view->parent == VIEW(REQ_VIEW_STATUS)) ||
3190                    (view == VIEW(REQ_VIEW_BLOB) &&
3191                      view->parent == VIEW(REQ_VIEW_TREE))) {
3192                         int line;
3193
3194                         view = view->parent;
3195                         line = view->lineno;
3196                         move_view(view, request);
3197                         if (view_is_displayed(view))
3198                                 update_view_title(view);
3199                         if (line != view->lineno)
3200                                 view->ops->request(view, REQ_ENTER,
3201                                                    &view->line[view->lineno]);
3202
3203                 } else {
3204                         move_view(view, request);
3205                 }
3206                 break;
3207
3208         case REQ_VIEW_NEXT:
3209         {
3210                 int nviews = displayed_views();
3211                 int next_view = (current_view + 1) % nviews;
3212
3213                 if (next_view == current_view) {
3214                         report("Only one view is displayed");
3215                         break;
3216                 }
3217
3218                 current_view = next_view;
3219                 /* Blur out the title of the previous view. */
3220                 update_view_title(view);
3221                 report("");
3222                 break;
3223         }
3224         case REQ_REFRESH:
3225                 report("Refreshing is not yet supported for the %s view", view->name);
3226                 break;
3227
3228         case REQ_MAXIMIZE:
3229                 if (displayed_views() == 2)
3230                         open_view(view, VIEW_REQ(view), OPEN_DEFAULT);
3231                 break;
3232
3233         case REQ_TOGGLE_LINENO:
3234                 toggle_view_option(&opt_line_number, "line numbers");
3235                 break;
3236
3237         case REQ_TOGGLE_DATE:
3238                 toggle_view_option(&opt_date, "date display");
3239                 break;
3240
3241         case REQ_TOGGLE_AUTHOR:
3242                 toggle_view_option(&opt_author, "author display");
3243                 break;
3244
3245         case REQ_TOGGLE_REV_GRAPH:
3246                 toggle_view_option(&opt_rev_graph, "revision graph display");
3247                 break;
3248
3249         case REQ_TOGGLE_REFS:
3250                 toggle_view_option(&opt_show_refs, "reference display");
3251                 break;
3252
3253         case REQ_SEARCH:
3254         case REQ_SEARCH_BACK:
3255                 search_view(view, request);
3256                 break;
3257
3258         case REQ_FIND_NEXT:
3259         case REQ_FIND_PREV:
3260                 find_next(view, request);
3261                 break;
3262
3263         case REQ_STOP_LOADING:
3264                 for (i = 0; i < ARRAY_SIZE(views); i++) {
3265                         view = &views[i];
3266                         if (view->pipe)
3267                                 report("Stopped loading the %s view", view->name),
3268                         end_update(view, TRUE);
3269                 }
3270                 break;
3271
3272         case REQ_SHOW_VERSION:
3273                 report("tig-%s (built %s)", TIG_VERSION, __DATE__);
3274                 return TRUE;
3275
3276         case REQ_SCREEN_REDRAW:
3277                 redraw_display(TRUE);
3278                 break;
3279
3280         case REQ_EDIT:
3281                 report("Nothing to edit");
3282                 break;
3283
3284         case REQ_ENTER:
3285                 report("Nothing to enter");
3286                 break;
3287
3288         case REQ_VIEW_CLOSE:
3289                 /* XXX: Mark closed views by letting view->parent point to the
3290                  * view itself. Parents to closed view should never be
3291                  * followed. */
3292                 if (view->parent &&
3293                     view->parent->parent != view->parent) {
3294                         memset(display, 0, sizeof(display));
3295                         current_view = 0;
3296                         display[current_view] = view->parent;
3297                         view->parent = view;
3298                         resize_display();
3299                         redraw_display(FALSE);
3300                         report("");
3301                         break;
3302                 }
3303                 /* Fall-through */
3304         case REQ_QUIT:
3305                 return FALSE;
3306
3307         default:
3308                 report("Unknown key, press 'h' for help");
3309                 return TRUE;
3310         }
3311
3312         return TRUE;
3313 }
3314
3315
3316 /*
3317  * View backend utilities
3318  */
3319
3320 /* Parse author lines where the name may be empty:
3321  *      author  <email@address.tld> 1138474660 +0100
3322  */
3323 static void
3324 parse_author_line(char *ident, char *author, size_t authorsize, struct tm *tm)
3325 {
3326         char *nameend = strchr(ident, '<');
3327         char *emailend = strchr(ident, '>');
3328
3329         if (nameend && emailend)
3330                 *nameend = *emailend = 0;
3331         ident = chomp_string(ident);
3332         if (!*ident) {
3333                 if (nameend)
3334                         ident = chomp_string(nameend + 1);
3335                 if (!*ident)
3336                         ident = "Unknown";
3337         }
3338
3339         string_ncopy_do(author, authorsize, ident, strlen(ident));
3340
3341         /* Parse epoch and timezone */
3342         if (emailend && emailend[1] == ' ') {
3343                 char *secs = emailend + 2;
3344                 char *zone = strchr(secs, ' ');
3345                 time_t time = (time_t) atol(secs);
3346
3347                 if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
3348                         long tz;
3349
3350                         zone++;
3351                         tz  = ('0' - zone[1]) * 60 * 60 * 10;
3352                         tz += ('0' - zone[2]) * 60 * 60;
3353                         tz += ('0' - zone[3]) * 60;
3354                         tz += ('0' - zone[4]) * 60;
3355
3356                         if (zone[0] == '-')
3357                                 tz = -tz;
3358
3359                         time -= tz;
3360                 }
3361
3362                 gmtime_r(&time, tm);
3363         }
3364 }
3365
3366 static enum input_status
3367 select_commit_parent_handler(void *data, char *buf, int c)
3368 {
3369         size_t parents = *(size_t *) data;
3370         int parent = 0;
3371
3372         if (!isdigit(c))
3373                 return INPUT_SKIP;
3374
3375         if (*buf)
3376                 parent = atoi(buf) * 10;
3377         parent += c - '0';
3378
3379         if (parent > parents)
3380                 return INPUT_SKIP;
3381         return INPUT_OK;
3382 }
3383
3384 static bool
3385 select_commit_parent(const char *id, char rev[SIZEOF_REV])
3386 {
3387         char buf[SIZEOF_STR * 4];
3388         const char *revlist_argv[] = {
3389                 "git", "rev-list", "-1", "--parents", id, NULL
3390         };
3391         int parents;
3392
3393         if (!run_io_buf(revlist_argv, buf, sizeof(buf)) ||
3394             !*chomp_string(buf) ||
3395             (parents = (strlen(buf) / 40) - 1) < 0) {
3396                 report("Failed to get parent information");
3397                 return FALSE;
3398
3399         } else if (parents == 0) {
3400                 report("The selected commit has no parents");
3401                 return FALSE;
3402         }
3403
3404         if (parents > 1) {
3405                 char prompt[SIZEOF_STR];
3406                 char *result;
3407
3408                 if (!string_format(prompt, "Which parent? [1..%d] ", parents))
3409                         return FALSE;
3410                 result = prompt_input(prompt, select_commit_parent_handler, &parents);
3411                 if (!result)
3412                         return FALSE;
3413                 parents = atoi(result);
3414         }
3415
3416         string_copy_rev(rev, &buf[41 * parents]);
3417         return TRUE;
3418 }
3419
3420 /*
3421  * Pager backend
3422  */
3423
3424 static bool
3425 pager_draw(struct view *view, struct line *line, unsigned int lineno)
3426 {
3427         char text[SIZEOF_STR];
3428
3429         if (opt_line_number && draw_lineno(view, lineno))
3430                 return TRUE;
3431
3432         string_expand(text, sizeof(text), line->data, opt_tab_size);
3433         draw_text(view, line->type, text, TRUE);
3434         return TRUE;
3435 }
3436
3437 static bool
3438 add_describe_ref(char *buf, size_t *bufpos, const char *commit_id, const char *sep)
3439 {
3440         const char *describe_argv[] = { "git", "describe", commit_id, NULL };
3441         char refbuf[SIZEOF_STR];
3442         char *ref = NULL;
3443
3444         if (run_io_buf(describe_argv, refbuf, sizeof(refbuf)))
3445                 ref = chomp_string(refbuf);
3446
3447         if (!ref || !*ref)
3448                 return TRUE;
3449
3450         /* This is the only fatal call, since it can "corrupt" the buffer. */
3451         if (!string_nformat(buf, SIZEOF_STR, bufpos, "%s%s", sep, ref))
3452                 return FALSE;
3453
3454         return TRUE;
3455 }
3456
3457 static void
3458 add_pager_refs(struct view *view, struct line *line)
3459 {
3460         char buf[SIZEOF_STR];
3461         char *commit_id = (char *)line->data + STRING_SIZE("commit ");
3462         struct ref **refs;
3463         size_t bufpos = 0, refpos = 0;
3464         const char *sep = "Refs: ";
3465         bool is_tag = FALSE;
3466
3467         assert(line->type == LINE_COMMIT);
3468
3469         refs = get_refs(commit_id);
3470         if (!refs) {
3471                 if (view == VIEW(REQ_VIEW_DIFF))
3472                         goto try_add_describe_ref;
3473                 return;
3474         }
3475
3476         do {
3477                 struct ref *ref = refs[refpos];
3478                 const char *fmt = ref->tag    ? "%s[%s]" :
3479                                   ref->remote ? "%s<%s>" : "%s%s";
3480
3481                 if (!string_format_from(buf, &bufpos, fmt, sep, ref->name))
3482                         return;
3483                 sep = ", ";
3484                 if (ref->tag)
3485                         is_tag = TRUE;
3486         } while (refs[refpos++]->next);
3487
3488         if (!is_tag && view == VIEW(REQ_VIEW_DIFF)) {
3489 try_add_describe_ref:
3490                 /* Add <tag>-g<commit_id> "fake" reference. */
3491                 if (!add_describe_ref(buf, &bufpos, commit_id, sep))
3492                         return;
3493         }
3494
3495         if (bufpos == 0)
3496                 return;
3497
3498         add_line_text(view, buf, LINE_PP_REFS);
3499 }
3500
3501 static bool
3502 pager_read(struct view *view, char *data)
3503 {
3504         struct line *line;
3505
3506         if (!data)
3507                 return TRUE;
3508
3509         line = add_line_text(view, data, get_line_type(data));
3510         if (!line)
3511                 return FALSE;
3512
3513         if (line->type == LINE_COMMIT &&
3514             (view == VIEW(REQ_VIEW_DIFF) ||
3515              view == VIEW(REQ_VIEW_LOG)))
3516                 add_pager_refs(view, line);
3517
3518         return TRUE;
3519 }
3520
3521 static enum request
3522 pager_request(struct view *view, enum request request, struct line *line)
3523 {
3524         int split = 0;
3525
3526         if (request != REQ_ENTER)
3527                 return request;
3528
3529         if (line->type == LINE_COMMIT &&
3530            (view == VIEW(REQ_VIEW_LOG) ||
3531             view == VIEW(REQ_VIEW_PAGER))) {
3532                 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
3533                 split = 1;
3534         }
3535
3536         /* Always scroll the view even if it was split. That way
3537          * you can use Enter to scroll through the log view and
3538          * split open each commit diff. */
3539         scroll_view(view, REQ_SCROLL_LINE_DOWN);
3540
3541         /* FIXME: A minor workaround. Scrolling the view will call report("")
3542          * but if we are scrolling a non-current view this won't properly
3543          * update the view title. */
3544         if (split)
3545                 update_view_title(view);
3546
3547         return REQ_NONE;
3548 }
3549
3550 static bool
3551 pager_grep(struct view *view, struct line *line)
3552 {
3553         regmatch_t pmatch;
3554         char *text = line->data;
3555
3556         if (!*text)
3557                 return FALSE;
3558
3559         if (regexec(view->regex, text, 1, &pmatch, 0) == REG_NOMATCH)
3560                 return FALSE;
3561
3562         return TRUE;
3563 }
3564
3565 static void
3566 pager_select(struct view *view, struct line *line)
3567 {
3568         if (line->type == LINE_COMMIT) {
3569                 char *text = (char *)line->data + STRING_SIZE("commit ");
3570
3571                 if (view != VIEW(REQ_VIEW_PAGER))
3572                         string_copy_rev(view->ref, text);
3573                 string_copy_rev(ref_commit, text);
3574         }
3575 }
3576
3577 static struct view_ops pager_ops = {
3578         "line",
3579         NULL,
3580         NULL,
3581         pager_read,
3582         pager_draw,
3583         pager_request,
3584         pager_grep,
3585         pager_select,
3586 };
3587
3588 static const char *log_argv[SIZEOF_ARG] = {
3589         "git", "log", "--no-color", "--cc", "--stat", "-n100", "%(head)", NULL
3590 };
3591
3592 static enum request
3593 log_request(struct view *view, enum request request, struct line *line)
3594 {
3595         switch (request) {
3596         case REQ_REFRESH:
3597                 load_refs();
3598                 open_view(view, REQ_VIEW_LOG, OPEN_REFRESH);
3599                 return REQ_NONE;
3600         default:
3601                 return pager_request(view, request, line);
3602         }
3603 }
3604
3605 static struct view_ops log_ops = {
3606         "line",
3607         log_argv,
3608         NULL,
3609         pager_read,
3610         pager_draw,
3611         log_request,
3612         pager_grep,
3613         pager_select,
3614 };
3615
3616 static const char *diff_argv[SIZEOF_ARG] = {
3617         "git", "show", "--pretty=fuller", "--no-color", "--root",
3618                 "--patch-with-stat", "--find-copies-harder", "-C", "%(commit)", NULL
3619 };
3620
3621 static struct view_ops diff_ops = {
3622         "line",
3623         diff_argv,
3624         NULL,
3625         pager_read,
3626         pager_draw,
3627         pager_request,
3628         pager_grep,
3629         pager_select,
3630 };
3631
3632 /*
3633  * Help backend
3634  */
3635
3636 static bool
3637 help_open(struct view *view)
3638 {
3639         char buf[SIZEOF_STR];
3640         size_t bufpos;
3641         int i;
3642
3643         if (view->lines > 0)
3644                 return TRUE;
3645
3646         add_line_text(view, "Quick reference for tig keybindings:", LINE_DEFAULT);
3647
3648         for (i = 0; i < ARRAY_SIZE(req_info); i++) {
3649                 const char *key;
3650
3651                 if (req_info[i].request == REQ_NONE)
3652                         continue;
3653
3654                 if (!req_info[i].request) {
3655                         add_line_text(view, "", LINE_DEFAULT);
3656                         add_line_text(view, req_info[i].help, LINE_DEFAULT);
3657                         continue;
3658                 }
3659
3660                 key = get_key(req_info[i].request);
3661                 if (!*key)
3662                         key = "(no key defined)";
3663
3664                 for (bufpos = 0; bufpos <= req_info[i].namelen; bufpos++) {
3665                         buf[bufpos] = tolower(req_info[i].name[bufpos]);
3666                         if (buf[bufpos] == '_')
3667                                 buf[bufpos] = '-';
3668                 }
3669
3670                 add_line_format(view, LINE_DEFAULT, "    %-25s %-20s %s",
3671                                 key, buf, req_info[i].help);
3672         }
3673
3674         if (run_requests) {
3675                 add_line_text(view, "", LINE_DEFAULT);
3676                 add_line_text(view, "External commands:", LINE_DEFAULT);
3677         }
3678
3679         for (i = 0; i < run_requests; i++) {
3680                 struct run_request *req = get_run_request(REQ_NONE + i + 1);
3681                 const char *key;
3682                 int argc;
3683
3684                 if (!req)
3685                         continue;
3686
3687                 key = get_key_name(req->key);
3688                 if (!*key)
3689                         key = "(no key defined)";
3690
3691                 for (bufpos = 0, argc = 0; req->argv[argc]; argc++)
3692                         if (!string_format_from(buf, &bufpos, "%s%s",
3693                                                 argc ? " " : "", req->argv[argc]))
3694                                 return REQ_NONE;
3695
3696                 add_line_format(view, LINE_DEFAULT, "    %-10s %-14s `%s`",
3697                                 keymap_table[req->keymap].name, key, buf);
3698         }
3699
3700         return TRUE;
3701 }
3702
3703 static struct view_ops help_ops = {
3704         "line",
3705         NULL,
3706         help_open,
3707         NULL,
3708         pager_draw,
3709         pager_request,
3710         pager_grep,
3711         pager_select,
3712 };
3713
3714
3715 /*
3716  * Tree backend
3717  */
3718
3719 struct tree_stack_entry {
3720         struct tree_stack_entry *prev;  /* Entry below this in the stack */
3721         unsigned long lineno;           /* Line number to restore */
3722         char *name;                     /* Position of name in opt_path */
3723 };
3724
3725 /* The top of the path stack. */
3726 static struct tree_stack_entry *tree_stack = NULL;
3727 unsigned long tree_lineno = 0;
3728
3729 static void
3730 pop_tree_stack_entry(void)
3731 {
3732         struct tree_stack_entry *entry = tree_stack;
3733
3734         tree_lineno = entry->lineno;
3735         entry->name[0] = 0;
3736         tree_stack = entry->prev;
3737         free(entry);
3738 }
3739
3740 static void
3741 push_tree_stack_entry(const char *name, unsigned long lineno)
3742 {
3743         struct tree_stack_entry *entry = calloc(1, sizeof(*entry));
3744         size_t pathlen = strlen(opt_path);
3745
3746         if (!entry)
3747                 return;
3748
3749         entry->prev = tree_stack;
3750         entry->name = opt_path + pathlen;
3751         tree_stack = entry;
3752
3753         if (!string_format_from(opt_path, &pathlen, "%s/", name)) {
3754                 pop_tree_stack_entry();
3755                 return;
3756         }
3757
3758         /* Move the current line to the first tree entry. */
3759         tree_lineno = 1;
3760         entry->lineno = lineno;
3761 }
3762
3763 /* Parse output from git-ls-tree(1):
3764  *
3765  * 100644 blob f931e1d229c3e185caad4449bf5b66ed72462657 tig.c
3766  */
3767
3768 #define SIZEOF_TREE_ATTR \
3769         STRING_SIZE("100644 blob f931e1d229c3e185caad4449bf5b66ed72462657\t")
3770
3771 #define SIZEOF_TREE_MODE \
3772         STRING_SIZE("100644 ")
3773
3774 #define TREE_ID_OFFSET \
3775         STRING_SIZE("100644 blob ")
3776
3777 struct tree_entry {
3778         char id[SIZEOF_REV];
3779         mode_t mode;
3780         struct tm time;                 /* Date from the author ident. */
3781         char author[75];                /* Author of the commit. */
3782         char name[1];
3783 };
3784
3785 static const char *
3786 tree_path(struct line *line)
3787 {
3788         return ((struct tree_entry *) line->data)->name;
3789 }
3790
3791
3792 static int
3793 tree_compare_entry(struct line *line1, struct line *line2)
3794 {
3795         if (line1->type != line2->type)
3796                 return line1->type == LINE_TREE_DIR ? -1 : 1;
3797         return strcmp(tree_path(line1), tree_path(line2));
3798 }
3799
3800 static struct line *
3801 tree_entry(struct view *view, enum line_type type, const char *path,
3802            const char *mode, const char *id)
3803 {
3804         struct tree_entry *entry = calloc(1, sizeof(*entry) + strlen(path));
3805         struct line *line = entry ? add_line_data(view, entry, type) : NULL;
3806
3807         if (!entry || !line) {
3808                 free(entry);
3809                 return NULL;
3810         }
3811
3812         strncpy(entry->name, path, strlen(path));
3813         if (mode)
3814                 entry->mode = strtoul(mode, NULL, 8);
3815         if (id)
3816                 string_copy_rev(entry->id, id);
3817
3818         return line;
3819 }
3820
3821 static bool
3822 tree_read_date(struct view *view, char *text, bool *read_date)
3823 {
3824         static char author_name[SIZEOF_STR];
3825         static struct tm author_time;
3826
3827         if (!text && *read_date) {
3828                 *read_date = FALSE;
3829                 return TRUE;
3830
3831         } else if (!text) {
3832                 char *path = *opt_path ? opt_path : ".";
3833                 /* Find next entry to process */
3834                 const char *log_file[] = {
3835                         "git", "log", "--no-color", "--pretty=raw",
3836                                 "--cc", "--raw", view->id, "--", path, NULL
3837                 };
3838                 struct io io = {};
3839
3840                 if (!view->lines) {
3841                         tree_entry(view, LINE_TREE_HEAD, opt_path, NULL, NULL);
3842                         report("Tree is empty");
3843                         return TRUE;
3844                 }
3845
3846                 if (!run_io_rd(&io, log_file, FORMAT_NONE)) {
3847                         report("Failed to load tree data");
3848                         return TRUE;
3849                 }
3850
3851                 done_io(view->pipe);
3852                 view->io = io;
3853                 *read_date = TRUE;
3854                 return FALSE;
3855
3856         } else if (*text == 'a' && get_line_type(text) == LINE_AUTHOR) {
3857                 parse_author_line(text + STRING_SIZE("author "),
3858                                   author_name, sizeof(author_name), &author_time);
3859
3860         } else if (*text == ':') {
3861                 char *pos;
3862                 size_t annotated = 1;
3863                 size_t i;
3864
3865                 pos = strchr(text, '\t');
3866                 if (!pos)
3867                         return TRUE;
3868                 text = pos + 1;
3869                 if (*opt_prefix && !strncmp(text, opt_prefix, strlen(opt_prefix)))
3870                         text += strlen(opt_prefix);
3871                 if (*opt_path && !strncmp(text, opt_path, strlen(opt_path)))
3872                         text += strlen(opt_path);
3873                 pos = strchr(text, '/');
3874                 if (pos)
3875                         *pos = 0;
3876
3877                 for (i = 1; i < view->lines; i++) {
3878                         struct line *line = &view->line[i];
3879                         struct tree_entry *entry = line->data;
3880
3881                         annotated += !!*entry->author;
3882                         if (*entry->author || strcmp(entry->name, text))
3883                                 continue;
3884
3885                         string_copy(entry->author, author_name);
3886                         memcpy(&entry->time, &author_time, sizeof(entry->time));
3887                         line->dirty = 1;
3888                         break;
3889                 }
3890
3891                 if (annotated == view->lines)
3892                         kill_io(view->pipe);
3893         }
3894         return TRUE;
3895 }
3896
3897 static bool
3898 tree_read(struct view *view, char *text)
3899 {
3900         static bool read_date = FALSE;
3901         struct tree_entry *data;
3902         struct line *entry, *line;
3903         enum line_type type;
3904         size_t textlen = text ? strlen(text) : 0;
3905         char *path = text + SIZEOF_TREE_ATTR;
3906
3907         if (read_date || !text)
3908                 return tree_read_date(view, text, &read_date);
3909
3910         if (textlen <= SIZEOF_TREE_ATTR)
3911                 return FALSE;
3912         if (view->lines == 0 &&
3913             !tree_entry(view, LINE_TREE_HEAD, opt_path, NULL, NULL))
3914                 return FALSE;
3915
3916         /* Strip the path part ... */
3917         if (*opt_path) {
3918                 size_t pathlen = textlen - SIZEOF_TREE_ATTR;
3919                 size_t striplen = strlen(opt_path);
3920
3921                 if (pathlen > striplen)
3922                         memmove(path, path + striplen,
3923                                 pathlen - striplen + 1);
3924
3925                 /* Insert "link" to parent directory. */
3926                 if (view->lines == 1 &&
3927                     !tree_entry(view, LINE_TREE_DIR, "..", "040000", view->ref))
3928                         return FALSE;
3929         }
3930
3931         type = text[SIZEOF_TREE_MODE] == 't' ? LINE_TREE_DIR : LINE_TREE_FILE;
3932         entry = tree_entry(view, type, path, text, text + TREE_ID_OFFSET);
3933         if (!entry)
3934                 return FALSE;
3935         data = entry->data;
3936
3937         /* Skip "Directory ..." and ".." line. */
3938         for (line = &view->line[1 + !!*opt_path]; line < entry; line++) {
3939                 if (tree_compare_entry(line, entry) <= 0)
3940                         continue;
3941
3942                 memmove(line + 1, line, (entry - line) * sizeof(*entry));
3943
3944                 line->data = data;
3945                 line->type = type;
3946                 for (; line <= entry; line++)
3947                         line->dirty = line->cleareol = 1;
3948                 return TRUE;
3949         }
3950
3951         if (tree_lineno > view->lineno) {
3952                 view->lineno = tree_lineno;
3953                 tree_lineno = 0;
3954         }
3955
3956         return TRUE;
3957 }
3958
3959 static bool
3960 tree_draw(struct view *view, struct line *line, unsigned int lineno)
3961 {
3962         struct tree_entry *entry = line->data;
3963
3964         if (line->type == LINE_TREE_HEAD) {
3965                 if (draw_text(view, line->type, "Directory path /", TRUE))
3966                         return TRUE;
3967         } else {
3968                 if (draw_mode(view, entry->mode))
3969                         return TRUE;
3970
3971                 if (opt_author && draw_author(view, entry->author))
3972                         return TRUE;
3973
3974                 if (opt_date && draw_date(view, *entry->author ? &entry->time : NULL))
3975                         return TRUE;
3976         }
3977         if (draw_text(view, line->type, entry->name, TRUE))
3978                 return TRUE;
3979         return TRUE;
3980 }
3981
3982 static void
3983 open_blob_editor()
3984 {
3985         char file[SIZEOF_STR] = "/tmp/tigblob.XXXXXX";
3986         int fd = mkstemp(file);
3987
3988         if (fd == -1)
3989                 report("Failed to create temporary file");
3990         else if (!run_io_append(blob_ops.argv, FORMAT_ALL, fd))
3991                 report("Failed to save blob data to file");
3992         else
3993                 open_editor(FALSE, file);
3994         if (fd != -1)
3995                 unlink(file);
3996 }
3997
3998 static enum request
3999 tree_request(struct view *view, enum request request, struct line *line)
4000 {
4001         enum open_flags flags;
4002
4003         switch (request) {
4004         case REQ_VIEW_BLAME:
4005                 if (line->type != LINE_TREE_FILE) {
4006                         report("Blame only supported for files");
4007                         return REQ_NONE;
4008                 }
4009
4010                 string_copy(opt_ref, view->vid);
4011                 return request;
4012
4013         case REQ_EDIT:
4014                 if (line->type != LINE_TREE_FILE) {
4015                         report("Edit only supported for files");
4016                 } else if (!is_head_commit(view->vid)) {
4017                         open_blob_editor();
4018                 } else {
4019                         open_editor(TRUE, opt_file);
4020                 }
4021                 return REQ_NONE;
4022
4023         case REQ_PARENT:
4024                 if (!*opt_path) {
4025                         /* quit view if at top of tree */
4026                         return REQ_VIEW_CLOSE;
4027                 }
4028                 /* fake 'cd  ..' */
4029                 line = &view->line[1];
4030                 break;
4031
4032         case REQ_ENTER:
4033                 break;
4034
4035         default:
4036                 return request;
4037         }
4038
4039         /* Cleanup the stack if the tree view is at a different tree. */
4040         while (!*opt_path && tree_stack)
4041                 pop_tree_stack_entry();
4042
4043         switch (line->type) {
4044         case LINE_TREE_DIR:
4045                 /* Depending on whether it is a subdirectory or parent link
4046                  * mangle the path buffer. */
4047                 if (line == &view->line[1] && *opt_path) {
4048                         pop_tree_stack_entry();
4049
4050                 } else {
4051                         const char *basename = tree_path(line);
4052
4053                         push_tree_stack_entry(basename, view->lineno);
4054                 }
4055
4056                 /* Trees and subtrees share the same ID, so they are not not
4057                  * unique like blobs. */
4058                 flags = OPEN_RELOAD;
4059                 request = REQ_VIEW_TREE;
4060                 break;
4061
4062         case LINE_TREE_FILE:
4063                 flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
4064                 request = REQ_VIEW_BLOB;
4065                 break;
4066
4067         default:
4068                 return REQ_NONE;
4069         }
4070
4071         open_view(view, request, flags);
4072         if (request == REQ_VIEW_TREE)
4073                 view->lineno = tree_lineno;
4074
4075         return REQ_NONE;
4076 }
4077
4078 static void
4079 tree_select(struct view *view, struct line *line)
4080 {
4081         struct tree_entry *entry = line->data;
4082
4083         if (line->type == LINE_TREE_FILE) {
4084                 string_copy_rev(ref_blob, entry->id);
4085                 string_format(opt_file, "%s%s", opt_path, tree_path(line));
4086
4087         } else if (line->type != LINE_TREE_DIR) {
4088                 return;
4089         }
4090
4091         string_copy_rev(view->ref, entry->id);
4092 }
4093
4094 static const char *tree_argv[SIZEOF_ARG] = {
4095         "git", "ls-tree", "%(commit)", "%(directory)", NULL
4096 };
4097
4098 static struct view_ops tree_ops = {
4099         "file",
4100         tree_argv,
4101         NULL,
4102         tree_read,
4103         tree_draw,
4104         tree_request,
4105         pager_grep,
4106         tree_select,
4107 };
4108
4109 static bool
4110 blob_read(struct view *view, char *line)
4111 {
4112         if (!line)
4113                 return TRUE;
4114         return add_line_text(view, line, LINE_DEFAULT) != NULL;
4115 }
4116
4117 static enum request
4118 blob_request(struct view *view, enum request request, struct line *line)
4119 {
4120         switch (request) {
4121         case REQ_EDIT:
4122                 open_blob_editor();
4123                 return REQ_NONE;
4124         default:
4125                 return pager_request(view, request, line);
4126         }
4127 }
4128
4129 static const char *blob_argv[SIZEOF_ARG] = {
4130         "git", "cat-file", "blob", "%(blob)", NULL
4131 };
4132
4133 static struct view_ops blob_ops = {
4134         "line",
4135         blob_argv,
4136         NULL,
4137         blob_read,
4138         pager_draw,
4139         blob_request,
4140         pager_grep,
4141         pager_select,
4142 };
4143
4144 /*
4145  * Blame backend
4146  *
4147  * Loading the blame view is a two phase job:
4148  *
4149  *  1. File content is read either using opt_file from the
4150  *     filesystem or using git-cat-file.
4151  *  2. Then blame information is incrementally added by
4152  *     reading output from git-blame.
4153  */
4154
4155 static const char *blame_head_argv[] = {
4156         "git", "blame", "--incremental", "--", "%(file)", NULL
4157 };
4158
4159 static const char *blame_ref_argv[] = {
4160         "git", "blame", "--incremental", "%(ref)", "--", "%(file)", NULL
4161 };
4162
4163 static const char *blame_cat_file_argv[] = {
4164         "git", "cat-file", "blob", "%(ref):%(file)", NULL
4165 };
4166
4167 struct blame_commit {
4168         char id[SIZEOF_REV];            /* SHA1 ID. */
4169         char title[128];                /* First line of the commit message. */
4170         char author[75];                /* Author of the commit. */
4171         struct tm time;                 /* Date from the author ident. */
4172         char filename[128];             /* Name of file. */
4173         bool has_previous;              /* Was a "previous" line detected. */
4174 };
4175
4176 struct blame {
4177         struct blame_commit *commit;
4178         char text[1];
4179 };
4180
4181 static bool
4182 blame_open(struct view *view)
4183 {
4184         if (*opt_ref || !io_open(&view->io, opt_file)) {
4185                 if (!run_io_rd(&view->io, blame_cat_file_argv, FORMAT_ALL))
4186                         return FALSE;
4187         }
4188
4189         setup_update(view, opt_file);
4190         string_format(view->ref, "%s ...", opt_file);
4191
4192         return TRUE;
4193 }
4194
4195 static struct blame_commit *
4196 get_blame_commit(struct view *view, const char *id)
4197 {
4198         size_t i;
4199
4200         for (i = 0; i < view->lines; i++) {
4201                 struct blame *blame = view->line[i].data;
4202
4203                 if (!blame->commit)
4204                         continue;
4205
4206                 if (!strncmp(blame->commit->id, id, SIZEOF_REV - 1))
4207                         return blame->commit;
4208         }
4209
4210         {
4211                 struct blame_commit *commit = calloc(1, sizeof(*commit));
4212
4213                 if (commit)
4214                         string_ncopy(commit->id, id, SIZEOF_REV);
4215                 return commit;
4216         }
4217 }
4218
4219 static bool
4220 parse_number(const char **posref, size_t *number, size_t min, size_t max)
4221 {
4222         const char *pos = *posref;
4223
4224         *posref = NULL;
4225         pos = strchr(pos + 1, ' ');
4226         if (!pos || !isdigit(pos[1]))
4227                 return FALSE;
4228         *number = atoi(pos + 1);
4229         if (*number < min || *number > max)
4230                 return FALSE;
4231
4232         *posref = pos;
4233         return TRUE;
4234 }
4235
4236 static struct blame_commit *
4237 parse_blame_commit(struct view *view, const char *text, int *blamed)
4238 {
4239         struct blame_commit *commit;
4240         struct blame *blame;
4241         const char *pos = text + SIZEOF_REV - 1;
4242         size_t lineno;
4243         size_t group;
4244
4245         if (strlen(text) <= SIZEOF_REV || *pos != ' ')
4246                 return NULL;
4247
4248         if (!parse_number(&pos, &lineno, 1, view->lines) ||
4249             !parse_number(&pos, &group, 1, view->lines - lineno + 1))
4250                 return NULL;
4251
4252         commit = get_blame_commit(view, text);
4253         if (!commit)
4254                 return NULL;
4255
4256         *blamed += group;
4257         while (group--) {
4258                 struct line *line = &view->line[lineno + group - 1];
4259
4260                 blame = line->data;
4261                 blame->commit = commit;
4262                 line->dirty = 1;
4263         }
4264
4265         return commit;
4266 }
4267
4268 static bool
4269 blame_read_file(struct view *view, const char *line, bool *read_file)
4270 {
4271         if (!line) {
4272                 const char **argv = *opt_ref ? blame_ref_argv : blame_head_argv;
4273                 struct io io = {};
4274
4275                 if (view->lines == 0 && !view->parent)
4276                         die("No blame exist for %s", view->vid);
4277
4278                 if (view->lines == 0 || !run_io_rd(&io, argv, FORMAT_ALL)) {
4279                         report("Failed to load blame data");
4280                         return TRUE;
4281                 }
4282
4283                 done_io(view->pipe);
4284                 view->io = io;
4285                 *read_file = FALSE;
4286                 return FALSE;
4287
4288         } else {
4289                 size_t linelen = string_expand_length(line, opt_tab_size);
4290                 struct blame *blame = malloc(sizeof(*blame) + linelen);
4291
4292                 if (!blame)
4293                         return FALSE;
4294
4295                 blame->commit = NULL;
4296                 string_expand(blame->text, linelen + 1, line, opt_tab_size);
4297                 return add_line_data(view, blame, LINE_BLAME_ID) != NULL;
4298         }
4299 }
4300
4301 static bool
4302 match_blame_header(const char *name, char **line)
4303 {
4304         size_t namelen = strlen(name);
4305         bool matched = !strncmp(name, *line, namelen);
4306
4307         if (matched)
4308                 *line += namelen;
4309
4310         return matched;
4311 }
4312
4313 static bool
4314 blame_read(struct view *view, char *line)
4315 {
4316         static struct blame_commit *commit = NULL;
4317         static int blamed = 0;
4318         static time_t author_time;
4319         static bool read_file = TRUE;
4320
4321         if (read_file)
4322                 return blame_read_file(view, line, &read_file);
4323
4324         if (!line) {
4325                 /* Reset all! */
4326                 commit = NULL;
4327                 blamed = 0;
4328                 read_file = TRUE;
4329                 string_format(view->ref, "%s", view->vid);
4330                 if (view_is_displayed(view)) {
4331                         update_view_title(view);
4332                         redraw_view_from(view, 0);
4333                 }
4334                 return TRUE;
4335         }
4336
4337         if (!commit) {
4338                 commit = parse_blame_commit(view, line, &blamed);
4339                 string_format(view->ref, "%s %2d%%", view->vid,
4340                               view->lines ? blamed * 100 / view->lines : 0);
4341
4342         } else if (match_blame_header("author ", &line)) {
4343                 string_ncopy(commit->author, line, strlen(line));
4344
4345         } else if (match_blame_header("author-time ", &line)) {
4346                 author_time = (time_t) atol(line);
4347
4348         } else if (match_blame_header("author-tz ", &line)) {
4349                 long tz;
4350
4351                 tz  = ('0' - line[1]) * 60 * 60 * 10;
4352                 tz += ('0' - line[2]) * 60 * 60;
4353                 tz += ('0' - line[3]) * 60;
4354                 tz += ('0' - line[4]) * 60;
4355
4356                 if (line[0] == '-')
4357                         tz = -tz;
4358
4359                 author_time -= tz;
4360                 gmtime_r(&author_time, &commit->time);
4361
4362         } else if (match_blame_header("summary ", &line)) {
4363                 string_ncopy(commit->title, line, strlen(line));
4364
4365         } else if (match_blame_header("previous ", &line)) {
4366                 commit->has_previous = TRUE;
4367
4368         } else if (match_blame_header("filename ", &line)) {
4369                 string_ncopy(commit->filename, line, strlen(line));
4370                 commit = NULL;
4371         }
4372
4373         return TRUE;
4374 }
4375
4376 static bool
4377 blame_draw(struct view *view, struct line *line, unsigned int lineno)
4378 {
4379         struct blame *blame = line->data;
4380         struct tm *time = NULL;
4381         const char *id = NULL, *author = NULL;
4382
4383         if (blame->commit && *blame->commit->filename) {
4384                 id = blame->commit->id;
4385                 author = blame->commit->author;
4386                 time = &blame->commit->time;
4387         }
4388
4389         if (opt_date && draw_date(view, time))
4390                 return TRUE;
4391
4392         if (opt_author && draw_author(view, author))
4393                 return TRUE;
4394
4395         if (draw_field(view, LINE_BLAME_ID, id, ID_COLS, FALSE))
4396                 return TRUE;
4397
4398         if (draw_lineno(view, lineno))
4399                 return TRUE;
4400
4401         draw_text(view, LINE_DEFAULT, blame->text, TRUE);
4402         return TRUE;
4403 }
4404
4405 static bool
4406 check_blame_commit(struct blame *blame)
4407 {
4408         if (!blame->commit)
4409                 report("Commit data not loaded yet");
4410         else if (!strcmp(blame->commit->id, NULL_ID))
4411                 report("No commit exist for the selected line");
4412         else
4413                 return TRUE;
4414         return FALSE;
4415 }
4416
4417 static enum request
4418 blame_request(struct view *view, enum request request, struct line *line)
4419 {
4420         enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
4421         struct blame *blame = line->data;
4422
4423         switch (request) {
4424         case REQ_VIEW_BLAME:
4425                 if (check_blame_commit(blame)) {
4426                         string_copy(opt_ref, blame->commit->id);
4427                         open_view(view, REQ_VIEW_BLAME, OPEN_REFRESH);
4428                 }
4429                 break;
4430
4431         case REQ_PARENT:
4432                 if (check_blame_commit(blame) &&
4433                     select_commit_parent(blame->commit->id, opt_ref))
4434                         open_view(view, REQ_VIEW_BLAME, OPEN_REFRESH);
4435                 break;
4436
4437         case REQ_ENTER:
4438                 if (!blame->commit) {
4439                         report("No commit loaded yet");
4440                         break;
4441                 }
4442
4443                 if (view_is_displayed(VIEW(REQ_VIEW_DIFF)) &&
4444                     !strcmp(blame->commit->id, VIEW(REQ_VIEW_DIFF)->ref))
4445                         break;
4446
4447                 if (!strcmp(blame->commit->id, NULL_ID)) {
4448                         struct view *diff = VIEW(REQ_VIEW_DIFF);
4449                         const char *diff_index_argv[] = {
4450                                 "git", "diff-index", "--root", "--patch-with-stat",
4451                                         "-C", "-M", "HEAD", "--", view->vid, NULL
4452                         };
4453
4454                         if (!blame->commit->has_previous) {
4455                                 diff_index_argv[1] = "diff";
4456                                 diff_index_argv[2] = "--no-color";
4457                                 diff_index_argv[6] = "--";
4458                                 diff_index_argv[7] = "/dev/null";
4459                         }
4460
4461                         if (!prepare_update(diff, diff_index_argv, NULL, FORMAT_DASH)) {
4462                                 report("Failed to allocate diff command");
4463                                 break;
4464                         }
4465                         flags |= OPEN_PREPARED;
4466                 }
4467
4468                 open_view(view, REQ_VIEW_DIFF, flags);
4469                 if (VIEW(REQ_VIEW_DIFF)->pipe && !strcmp(blame->commit->id, NULL_ID))
4470                         string_copy_rev(VIEW(REQ_VIEW_DIFF)->ref, NULL_ID);
4471                 break;
4472
4473         default:
4474                 return request;
4475         }
4476
4477         return REQ_NONE;
4478 }
4479
4480 static bool
4481 blame_grep(struct view *view, struct line *line)
4482 {
4483         struct blame *blame = line->data;
4484         struct blame_commit *commit = blame->commit;
4485         regmatch_t pmatch;
4486
4487 #define MATCH(text, on)                                                 \
4488         (on && *text && regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
4489
4490         if (commit) {
4491                 char buf[DATE_COLS + 1];
4492
4493                 if (MATCH(commit->title, 1) ||
4494                     MATCH(commit->author, opt_author) ||
4495                     MATCH(commit->id, opt_date))
4496                         return TRUE;
4497
4498                 if (strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time) &&
4499                     MATCH(buf, 1))
4500                         return TRUE;
4501         }
4502
4503         return MATCH(blame->text, 1);
4504
4505 #undef MATCH
4506 }
4507
4508 static void
4509 blame_select(struct view *view, struct line *line)
4510 {
4511         struct blame *blame = line->data;
4512         struct blame_commit *commit = blame->commit;
4513
4514         if (!commit)
4515                 return;
4516
4517         if (!strcmp(commit->id, NULL_ID))
4518                 string_ncopy(ref_commit, "HEAD", 4);
4519         else
4520                 string_copy_rev(ref_commit, commit->id);
4521 }
4522
4523 static struct view_ops blame_ops = {
4524         "line",
4525         NULL,
4526         blame_open,
4527         blame_read,
4528         blame_draw,
4529         blame_request,
4530         blame_grep,
4531         blame_select,
4532 };
4533
4534 /*
4535  * Status backend
4536  */
4537
4538 struct status {
4539         char status;
4540         struct {
4541                 mode_t mode;
4542                 char rev[SIZEOF_REV];
4543                 char name[SIZEOF_STR];
4544         } old;
4545         struct {
4546                 mode_t mode;
4547                 char rev[SIZEOF_REV];
4548                 char name[SIZEOF_STR];
4549         } new;
4550 };
4551
4552 static char status_onbranch[SIZEOF_STR];
4553 static struct status stage_status;
4554 static enum line_type stage_line_type;
4555 static size_t stage_chunks;
4556 static int *stage_chunk;
4557
4558 /* This should work even for the "On branch" line. */
4559 static inline bool
4560 status_has_none(struct view *view, struct line *line)
4561 {
4562         return line < view->line + view->lines && !line[1].data;
4563 }
4564
4565 /* Get fields from the diff line:
4566  * :100644 100644 06a5d6ae9eca55be2e0e585a152e6b1336f2b20e 0000000000000000000000000000000000000000 M
4567  */
4568 static inline bool
4569 status_get_diff(struct status *file, const char *buf, size_t bufsize)
4570 {
4571         const char *old_mode = buf +  1;
4572         const char *new_mode = buf +  8;
4573         const char *old_rev  = buf + 15;
4574         const char *new_rev  = buf + 56;
4575         const char *status   = buf + 97;
4576
4577         if (bufsize < 98 ||
4578             old_mode[-1] != ':' ||
4579             new_mode[-1] != ' ' ||
4580             old_rev[-1]  != ' ' ||
4581             new_rev[-1]  != ' ' ||
4582             status[-1]   != ' ')
4583                 return FALSE;
4584
4585         file->status = *status;
4586
4587         string_copy_rev(file->old.rev, old_rev);
4588         string_copy_rev(file->new.rev, new_rev);
4589
4590         file->old.mode = strtoul(old_mode, NULL, 8);
4591         file->new.mode = strtoul(new_mode, NULL, 8);
4592
4593         file->old.name[0] = file->new.name[0] = 0;
4594
4595         return TRUE;
4596 }
4597
4598 static bool
4599 status_run(struct view *view, const char *argv[], char status, enum line_type type)
4600 {
4601         struct status *unmerged = NULL;
4602         char *buf;
4603         struct io io = {};
4604
4605         if (!run_io(&io, argv, NULL, IO_RD))
4606                 return FALSE;
4607
4608         add_line_data(view, NULL, type);
4609
4610         while ((buf = io_get(&io, 0, TRUE))) {
4611                 struct status *file = unmerged;
4612
4613                 if (!file) {
4614                         file = calloc(1, sizeof(*file));
4615                         if (!file || !add_line_data(view, file, type))
4616                                 goto error_out;
4617                 }
4618
4619                 /* Parse diff info part. */
4620                 if (status) {
4621                         file->status = status;
4622                         if (status == 'A')
4623                                 string_copy(file->old.rev, NULL_ID);
4624
4625                 } else if (!file->status || file == unmerged) {
4626                         if (!status_get_diff(file, buf, strlen(buf)))
4627                                 goto error_out;
4628
4629                         buf = io_get(&io, 0, TRUE);
4630                         if (!buf)
4631                                 break;
4632
4633                         /* Collapse all modified entries that follow an
4634                          * associated unmerged entry. */
4635                         if (unmerged == file) {
4636                                 unmerged->status = 'U';
4637                                 unmerged = NULL;
4638                         } else if (file->status == 'U') {
4639                                 unmerged = file;
4640                         }
4641                 }
4642
4643                 /* Grab the old name for rename/copy. */
4644                 if (!*file->old.name &&
4645                     (file->status == 'R' || file->status == 'C')) {
4646                         string_ncopy(file->old.name, buf, strlen(buf));
4647
4648                         buf = io_get(&io, 0, TRUE);
4649                         if (!buf)
4650                                 break;
4651                 }
4652
4653                 /* git-ls-files just delivers a NUL separated list of
4654                  * file names similar to the second half of the
4655                  * git-diff-* output. */
4656                 string_ncopy(file->new.name, buf, strlen(buf));
4657                 if (!*file->old.name)
4658                         string_copy(file->old.name, file->new.name);
4659                 file = NULL;
4660         }
4661
4662         if (io_error(&io)) {
4663 error_out:
4664                 done_io(&io);
4665                 return FALSE;
4666         }
4667
4668         if (!view->line[view->lines - 1].data)
4669                 add_line_data(view, NULL, LINE_STAT_NONE);
4670
4671         done_io(&io);
4672         return TRUE;
4673 }
4674
4675 /* Don't show unmerged entries in the staged section. */
4676 static const char *status_diff_index_argv[] = {
4677         "git", "diff-index", "-z", "--diff-filter=ACDMRTXB",
4678                              "--cached", "-M", "HEAD", NULL
4679 };
4680
4681 static const char *status_diff_files_argv[] = {
4682         "git", "diff-files", "-z", NULL
4683 };
4684
4685 static const char *status_list_other_argv[] = {
4686         "git", "ls-files", "-z", "--others", "--exclude-standard", NULL
4687 };
4688
4689 static const char *status_list_no_head_argv[] = {
4690         "git", "ls-files", "-z", "--cached", "--exclude-standard", NULL
4691 };
4692
4693 static const char *update_index_argv[] = {
4694         "git", "update-index", "-q", "--unmerged", "--refresh", NULL
4695 };
4696
4697 /* Restore the previous line number to stay in the context or select a
4698  * line with something that can be updated. */
4699 static void
4700 status_restore(struct view *view)
4701 {
4702         if (view->p_lineno >= view->lines)
4703                 view->p_lineno = view->lines - 1;
4704         while (view->p_lineno < view->lines && !view->line[view->p_lineno].data)
4705                 view->p_lineno++;
4706         while (view->p_lineno > 0 && !view->line[view->p_lineno].data)
4707                 view->p_lineno--;
4708
4709         /* If the above fails, always skip the "On branch" line. */
4710         if (view->p_lineno < view->lines)
4711                 view->lineno = view->p_lineno;
4712         else
4713                 view->lineno = 1;
4714
4715         if (view->lineno < view->offset)
4716                 view->offset = view->lineno;
4717         else if (view->offset + view->height <= view->lineno)
4718                 view->offset = view->lineno - view->height + 1;
4719
4720         view->p_restore = FALSE;
4721 }
4722
4723 /* First parse staged info using git-diff-index(1), then parse unstaged
4724  * info using git-diff-files(1), and finally untracked files using
4725  * git-ls-files(1). */
4726 static bool
4727 status_open(struct view *view)
4728 {
4729         reset_view(view);
4730
4731         add_line_data(view, NULL, LINE_STAT_HEAD);
4732         if (is_initial_commit())
4733                 string_copy(status_onbranch, "Initial commit");
4734         else if (!*opt_head)
4735                 string_copy(status_onbranch, "Not currently on any branch");
4736         else if (!string_format(status_onbranch, "On branch %s", opt_head))
4737                 return FALSE;
4738
4739         run_io_bg(update_index_argv);
4740
4741         if (is_initial_commit()) {
4742                 if (!status_run(view, status_list_no_head_argv, 'A', LINE_STAT_STAGED))
4743                         return FALSE;
4744         } else if (!status_run(view, status_diff_index_argv, 0, LINE_STAT_STAGED)) {
4745                 return FALSE;
4746         }
4747
4748         if (!status_run(view, status_diff_files_argv, 0, LINE_STAT_UNSTAGED) ||
4749             !status_run(view, status_list_other_argv, '?', LINE_STAT_UNTRACKED))
4750                 return FALSE;
4751
4752         /* Restore the exact position or use the specialized restore
4753          * mode? */
4754         if (!view->p_restore)
4755                 status_restore(view);
4756         return TRUE;
4757 }
4758
4759 static bool
4760 status_draw(struct view *view, struct line *line, unsigned int lineno)
4761 {
4762         struct status *status = line->data;
4763         enum line_type type;
4764         const char *text;
4765
4766         if (!status) {
4767                 switch (line->type) {
4768                 case LINE_STAT_STAGED:
4769                         type = LINE_STAT_SECTION;
4770                         text = "Changes to be committed:";
4771                         break;
4772
4773                 case LINE_STAT_UNSTAGED:
4774                         type = LINE_STAT_SECTION;
4775                         text = "Changed but not updated:";
4776                         break;
4777
4778                 case LINE_STAT_UNTRACKED:
4779                         type = LINE_STAT_SECTION;
4780                         text = "Untracked files:";
4781                         break;
4782
4783                 case LINE_STAT_NONE:
4784                         type = LINE_DEFAULT;
4785                         text = "  (no files)";
4786                         break;
4787
4788                 case LINE_STAT_HEAD:
4789                         type = LINE_STAT_HEAD;
4790                         text = status_onbranch;
4791                         break;
4792
4793                 default:
4794                         return FALSE;
4795                 }
4796         } else {
4797                 static char buf[] = { '?', ' ', ' ', ' ', 0 };
4798
4799                 buf[0] = status->status;
4800                 if (draw_text(view, line->type, buf, TRUE))
4801                         return TRUE;
4802                 type = LINE_DEFAULT;
4803                 text = status->new.name;
4804         }
4805
4806         draw_text(view, type, text, TRUE);
4807         return TRUE;
4808 }
4809
4810 static enum request
4811 status_enter(struct view *view, struct line *line)
4812 {
4813         struct status *status = line->data;
4814         const char *oldpath = status ? status->old.name : NULL;
4815         /* Diffs for unmerged entries are empty when passing the new
4816          * path, so leave it empty. */
4817         const char *newpath = status && status->status != 'U' ? status->new.name : NULL;
4818         const char *info;
4819         enum open_flags split;
4820         struct view *stage = VIEW(REQ_VIEW_STAGE);
4821
4822         if (line->type == LINE_STAT_NONE ||
4823             (!status && line[1].type == LINE_STAT_NONE)) {
4824                 report("No file to diff");
4825                 return REQ_NONE;
4826         }
4827
4828         switch (line->type) {
4829         case LINE_STAT_STAGED:
4830                 if (is_initial_commit()) {
4831                         const char *no_head_diff_argv[] = {
4832                                 "git", "diff", "--no-color", "--patch-with-stat",
4833                                         "--", "/dev/null", newpath, NULL
4834                         };
4835
4836                         if (!prepare_update(stage, no_head_diff_argv, opt_cdup, FORMAT_DASH))
4837                                 return REQ_QUIT;
4838                 } else {
4839                         const char *index_show_argv[] = {
4840                                 "git", "diff-index", "--root", "--patch-with-stat",
4841                                         "-C", "-M", "--cached", "HEAD", "--",
4842                                         oldpath, newpath, NULL
4843                         };
4844
4845                         if (!prepare_update(stage, index_show_argv, opt_cdup, FORMAT_DASH))
4846                                 return REQ_QUIT;
4847                 }
4848
4849                 if (status)
4850                         info = "Staged changes to %s";
4851                 else
4852                         info = "Staged changes";
4853                 break;
4854
4855         case LINE_STAT_UNSTAGED:
4856         {
4857                 const char *files_show_argv[] = {
4858                         "git", "diff-files", "--root", "--patch-with-stat",
4859                                 "-C", "-M", "--", oldpath, newpath, NULL
4860                 };
4861
4862                 if (!prepare_update(stage, files_show_argv, opt_cdup, FORMAT_DASH))
4863                         return REQ_QUIT;
4864                 if (status)
4865                         info = "Unstaged changes to %s";
4866                 else
4867                         info = "Unstaged changes";
4868                 break;
4869         }
4870         case LINE_STAT_UNTRACKED:
4871                 if (!newpath) {
4872                         report("No file to show");
4873                         return REQ_NONE;
4874                 }
4875
4876                 if (!suffixcmp(status->new.name, -1, "/")) {
4877                         report("Cannot display a directory");
4878                         return REQ_NONE;
4879                 }
4880
4881                 if (!prepare_update_file(stage, newpath))
4882                         return REQ_QUIT;
4883                 info = "Untracked file %s";
4884                 break;
4885
4886         case LINE_STAT_HEAD:
4887                 return REQ_NONE;
4888
4889         default:
4890                 die("line type %d not handled in switch", line->type);
4891         }
4892
4893         split = view_is_displayed(view) ? OPEN_SPLIT : 0;
4894         open_view(view, REQ_VIEW_STAGE, OPEN_PREPARED | split);
4895         if (view_is_displayed(VIEW(REQ_VIEW_STAGE))) {
4896                 if (status) {
4897                         stage_status = *status;
4898                 } else {
4899                         memset(&stage_status, 0, sizeof(stage_status));
4900                 }
4901
4902                 stage_line_type = line->type;
4903                 stage_chunks = 0;
4904                 string_format(VIEW(REQ_VIEW_STAGE)->ref, info, stage_status.new.name);
4905         }
4906
4907         return REQ_NONE;
4908 }
4909
4910 static bool
4911 status_exists(struct status *status, enum line_type type)
4912 {
4913         struct view *view = VIEW(REQ_VIEW_STATUS);
4914         unsigned long lineno;
4915
4916         for (lineno = 0; lineno < view->lines; lineno++) {
4917                 struct line *line = &view->line[lineno];
4918                 struct status *pos = line->data;
4919
4920                 if (line->type != type)
4921                         continue;
4922                 if (!pos && (!status || !status->status) && line[1].data) {
4923                         select_view_line(view, lineno);
4924                         return TRUE;
4925                 }
4926                 if (pos && !strcmp(status->new.name, pos->new.name)) {
4927                         select_view_line(view, lineno);
4928                         return TRUE;
4929                 }
4930         }
4931
4932         return FALSE;
4933 }
4934
4935
4936 static bool
4937 status_update_prepare(struct io *io, enum line_type type)
4938 {
4939         const char *staged_argv[] = {
4940                 "git", "update-index", "-z", "--index-info", NULL
4941         };
4942         const char *others_argv[] = {
4943                 "git", "update-index", "-z", "--add", "--remove", "--stdin", NULL
4944         };
4945
4946         switch (type) {
4947         case LINE_STAT_STAGED:
4948                 return run_io(io, staged_argv, opt_cdup, IO_WR);
4949
4950         case LINE_STAT_UNSTAGED:
4951                 return run_io(io, others_argv, opt_cdup, IO_WR);
4952
4953         case LINE_STAT_UNTRACKED:
4954                 return run_io(io, others_argv, NULL, IO_WR);
4955
4956         default:
4957                 die("line type %d not handled in switch", type);
4958                 return FALSE;
4959         }
4960 }
4961
4962 static bool
4963 status_update_write(struct io *io, struct status *status, enum line_type type)
4964 {
4965         char buf[SIZEOF_STR];
4966         size_t bufsize = 0;
4967
4968         switch (type) {
4969         case LINE_STAT_STAGED:
4970                 if (!string_format_from(buf, &bufsize, "%06o %s\t%s%c",
4971                                         status->old.mode,
4972                                         status->old.rev,
4973                                         status->old.name, 0))
4974                         return FALSE;
4975                 break;
4976
4977         case LINE_STAT_UNSTAGED:
4978         case LINE_STAT_UNTRACKED:
4979                 if (!string_format_from(buf, &bufsize, "%s%c", status->new.name, 0))
4980                         return FALSE;
4981                 break;
4982
4983         default:
4984                 die("line type %d not handled in switch", type);
4985         }
4986
4987         return io_write(io, buf, bufsize);
4988 }
4989
4990 static bool
4991 status_update_file(struct status *status, enum line_type type)
4992 {
4993         struct io io = {};
4994         bool result;
4995
4996         if (!status_update_prepare(&io, type))
4997                 return FALSE;
4998
4999         result = status_update_write(&io, status, type);
5000         done_io(&io);
5001         return result;
5002 }
5003
5004 static bool
5005 status_update_files(struct view *view, struct line *line)
5006 {
5007         struct io io = {};
5008         bool result = TRUE;
5009         struct line *pos = view->line + view->lines;
5010         int files = 0;
5011         int file, done;
5012
5013         if (!status_update_prepare(&io, line->type))
5014                 return FALSE;
5015
5016         for (pos = line; pos < view->line + view->lines && pos->data; pos++)
5017                 files++;
5018
5019         for (file = 0, done = 0; result && file < files; line++, file++) {
5020                 int almost_done = file * 100 / files;
5021
5022                 if (almost_done > done) {
5023                         done = almost_done;
5024                         string_format(view->ref, "updating file %u of %u (%d%% done)",
5025                                       file, files, done);
5026                         update_view_title(view);
5027                 }
5028                 result = status_update_write(&io, line->data, line->type);
5029         }
5030
5031         done_io(&io);
5032         return result;
5033 }
5034
5035 static bool
5036 status_update(struct view *view)
5037 {
5038         struct line *line = &view->line[view->lineno];
5039
5040         assert(view->lines);
5041
5042         if (!line->data) {
5043                 /* This should work even for the "On branch" line. */
5044                 if (line < view->line + view->lines && !line[1].data) {
5045                         report("Nothing to update");
5046                         return FALSE;
5047                 }
5048
5049                 if (!status_update_files(view, line + 1)) {
5050                         report("Failed to update file status");
5051                         return FALSE;
5052                 }
5053
5054         } else if (!status_update_file(line->data, line->type)) {
5055                 report("Failed to update file status");
5056                 return FALSE;
5057         }
5058
5059         return TRUE;
5060 }
5061
5062 static bool
5063 status_revert(struct status *status, enum line_type type, bool has_none)
5064 {
5065         if (!status || type != LINE_STAT_UNSTAGED) {
5066                 if (type == LINE_STAT_STAGED) {
5067                         report("Cannot revert changes to staged files");
5068                 } else if (type == LINE_STAT_UNTRACKED) {
5069                         report("Cannot revert changes to untracked files");
5070                 } else if (has_none) {
5071                         report("Nothing to revert");
5072                 } else {
5073                         report("Cannot revert changes to multiple files");
5074                 }
5075                 return FALSE;
5076
5077         } else {
5078                 char mode[10] = "100644";
5079                 const char *reset_argv[] = {
5080                         "git", "update-index", "--cacheinfo", mode,
5081                                 status->old.rev, status->old.name, NULL
5082                 };
5083                 const char *checkout_argv[] = {
5084                         "git", "checkout", "--", status->old.name, NULL
5085                 };
5086
5087                 if (!prompt_yesno("Are you sure you want to overwrite any changes?"))
5088                         return FALSE;
5089                 string_format(mode, "%o", status->old.mode);
5090                 return (status->status != 'U' || run_io_fg(reset_argv, opt_cdup)) &&
5091                         run_io_fg(checkout_argv, opt_cdup);
5092         }
5093 }
5094
5095 static enum request
5096 status_request(struct view *view, enum request request, struct line *line)
5097 {
5098         struct status *status = line->data;
5099
5100         switch (request) {
5101         case REQ_STATUS_UPDATE:
5102                 if (!status_update(view))
5103                         return REQ_NONE;
5104                 break;
5105
5106         case REQ_STATUS_REVERT:
5107                 if (!status_revert(status, line->type, status_has_none(view, line)))
5108                         return REQ_NONE;
5109                 break;
5110
5111         case REQ_STATUS_MERGE:
5112                 if (!status || status->status != 'U') {
5113                         report("Merging only possible for files with unmerged status ('U').");
5114                         return REQ_NONE;
5115                 }
5116                 open_mergetool(status->new.name);
5117                 break;
5118
5119         case REQ_EDIT:
5120                 if (!status)
5121                         return request;
5122                 if (status->status == 'D') {
5123                         report("File has been deleted.");
5124                         return REQ_NONE;
5125                 }
5126
5127                 open_editor(status->status != '?', status->new.name);
5128                 break;
5129
5130         case REQ_VIEW_BLAME:
5131                 if (status) {
5132                         string_copy(opt_file, status->new.name);
5133                         opt_ref[0] = 0;
5134                 }
5135                 return request;
5136
5137         case REQ_ENTER:
5138                 /* After returning the status view has been split to
5139                  * show the stage view. No further reloading is
5140                  * necessary. */
5141                 status_enter(view, line);
5142                 return REQ_NONE;
5143
5144         case REQ_REFRESH:
5145                 /* Simply reload the view. */
5146                 break;
5147
5148         default:
5149                 return request;
5150         }
5151
5152         open_view(view, REQ_VIEW_STATUS, OPEN_RELOAD);
5153
5154         return REQ_NONE;
5155 }
5156
5157 static void
5158 status_select(struct view *view, struct line *line)
5159 {
5160         struct status *status = line->data;
5161         char file[SIZEOF_STR] = "all files";
5162         const char *text;
5163         const char *key;
5164
5165         if (status && !string_format(file, "'%s'", status->new.name))
5166                 return;
5167
5168         if (!status && line[1].type == LINE_STAT_NONE)
5169                 line++;
5170
5171         switch (line->type) {
5172         case LINE_STAT_STAGED:
5173                 text = "Press %s to unstage %s for commit";
5174                 break;
5175
5176         case LINE_STAT_UNSTAGED:
5177                 text = "Press %s to stage %s for commit";
5178                 break;
5179
5180         case LINE_STAT_UNTRACKED:
5181                 text = "Press %s to stage %s for addition";
5182                 break;
5183
5184         case LINE_STAT_HEAD:
5185         case LINE_STAT_NONE:
5186                 text = "Nothing to update";
5187                 break;
5188
5189         default:
5190                 die("line type %d not handled in switch", line->type);
5191         }
5192
5193         if (status && status->status == 'U') {
5194                 text = "Press %s to resolve conflict in %s";
5195                 key = get_key(REQ_STATUS_MERGE);
5196
5197         } else {
5198                 key = get_key(REQ_STATUS_UPDATE);
5199         }
5200
5201         string_format(view->ref, text, key, file);
5202 }
5203
5204 static bool
5205 status_grep(struct view *view, struct line *line)
5206 {
5207         struct status *status = line->data;
5208         enum { S_STATUS, S_NAME, S_END } state;
5209         char buf[2] = "?";
5210         regmatch_t pmatch;
5211
5212         if (!status)
5213                 return FALSE;
5214
5215         for (state = S_STATUS; state < S_END; state++) {
5216                 const char *text;
5217
5218                 switch (state) {
5219                 case S_NAME:    text = status->new.name;        break;
5220                 case S_STATUS:
5221                         buf[0] = status->status;
5222                         text = buf;
5223                         break;
5224
5225                 default:
5226                         return FALSE;
5227                 }
5228
5229                 if (regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
5230                         return TRUE;
5231         }
5232
5233         return FALSE;
5234 }
5235
5236 static struct view_ops status_ops = {
5237         "file",
5238         NULL,
5239         status_open,
5240         NULL,
5241         status_draw,
5242         status_request,
5243         status_grep,
5244         status_select,
5245 };
5246
5247
5248 static bool
5249 stage_diff_write(struct io *io, struct line *line, struct line *end)
5250 {
5251         while (line < end) {
5252                 if (!io_write(io, line->data, strlen(line->data)) ||
5253                     !io_write(io, "\n", 1))
5254                         return FALSE;
5255                 line++;
5256                 if (line->type == LINE_DIFF_CHUNK ||
5257                     line->type == LINE_DIFF_HEADER)
5258                         break;
5259         }
5260
5261         return TRUE;
5262 }
5263
5264 static struct line *
5265 stage_diff_find(struct view *view, struct line *line, enum line_type type)
5266 {
5267         for (; view->line < line; line--)
5268                 if (line->type == type)
5269                         return line;
5270
5271         return NULL;
5272 }
5273
5274 static bool
5275 stage_apply_chunk(struct view *view, struct line *chunk, bool revert)
5276 {
5277         const char *apply_argv[SIZEOF_ARG] = {
5278                 "git", "apply", "--whitespace=nowarn", NULL
5279         };
5280         struct line *diff_hdr;
5281         struct io io = {};
5282         int argc = 3;
5283
5284         diff_hdr = stage_diff_find(view, chunk, LINE_DIFF_HEADER);
5285         if (!diff_hdr)
5286                 return FALSE;
5287
5288         if (!revert)
5289                 apply_argv[argc++] = "--cached";
5290         if (revert || stage_line_type == LINE_STAT_STAGED)
5291                 apply_argv[argc++] = "-R";
5292         apply_argv[argc++] = "-";
5293         apply_argv[argc++] = NULL;
5294         if (!run_io(&io, apply_argv, opt_cdup, IO_WR))
5295                 return FALSE;
5296
5297         if (!stage_diff_write(&io, diff_hdr, chunk) ||
5298             !stage_diff_write(&io, chunk, view->line + view->lines))
5299                 chunk = NULL;
5300
5301         done_io(&io);
5302         run_io_bg(update_index_argv);
5303
5304         return chunk ? TRUE : FALSE;
5305 }
5306
5307 static bool
5308 stage_update(struct view *view, struct line *line)
5309 {
5310         struct line *chunk = NULL;
5311
5312         if (!is_initial_commit() && stage_line_type != LINE_STAT_UNTRACKED)
5313                 chunk = stage_diff_find(view, line, LINE_DIFF_CHUNK);
5314
5315         if (chunk) {
5316                 if (!stage_apply_chunk(view, chunk, FALSE)) {
5317                         report("Failed to apply chunk");
5318                         return FALSE;
5319                 }
5320
5321         } else if (!stage_status.status) {
5322                 view = VIEW(REQ_VIEW_STATUS);
5323
5324                 for (line = view->line; line < view->line + view->lines; line++)
5325                         if (line->type == stage_line_type)
5326                                 break;
5327
5328                 if (!status_update_files(view, line + 1)) {
5329                         report("Failed to update files");
5330                         return FALSE;
5331                 }
5332
5333         } else if (!status_update_file(&stage_status, stage_line_type)) {
5334                 report("Failed to update file");
5335                 return FALSE;
5336         }
5337
5338         return TRUE;
5339 }
5340
5341 static bool
5342 stage_revert(struct view *view, struct line *line)
5343 {
5344         struct line *chunk = NULL;
5345
5346         if (!is_initial_commit() && stage_line_type == LINE_STAT_UNSTAGED)
5347                 chunk = stage_diff_find(view, line, LINE_DIFF_CHUNK);
5348
5349         if (chunk) {
5350                 if (!prompt_yesno("Are you sure you want to revert changes?"))
5351                         return FALSE;
5352
5353                 if (!stage_apply_chunk(view, chunk, TRUE)) {
5354                         report("Failed to revert chunk");
5355                         return FALSE;
5356                 }
5357                 return TRUE;
5358
5359         } else {
5360                 return status_revert(stage_status.status ? &stage_status : NULL,
5361                                      stage_line_type, FALSE);
5362         }
5363 }
5364
5365
5366 static void
5367 stage_next(struct view *view, struct line *line)
5368 {
5369         int i;
5370
5371         if (!stage_chunks) {
5372                 static size_t alloc = 0;
5373                 int *tmp;
5374
5375                 for (line = view->line; line < view->line + view->lines; line++) {
5376                         if (line->type != LINE_DIFF_CHUNK)
5377                                 continue;
5378
5379                         tmp = realloc_items(stage_chunk, &alloc,
5380                                             stage_chunks, sizeof(*tmp));
5381                         if (!tmp) {
5382                                 report("Allocation failure");
5383                                 return;
5384                         }
5385
5386                         stage_chunk = tmp;
5387                         stage_chunk[stage_chunks++] = line - view->line;
5388                 }
5389         }
5390
5391         for (i = 0; i < stage_chunks; i++) {
5392                 if (stage_chunk[i] > view->lineno) {
5393                         do_scroll_view(view, stage_chunk[i] - view->lineno);
5394                         report("Chunk %d of %d", i + 1, stage_chunks);
5395                         return;
5396                 }
5397         }
5398
5399         report("No next chunk found");
5400 }
5401
5402 static enum request
5403 stage_request(struct view *view, enum request request, struct line *line)
5404 {
5405         switch (request) {
5406         case REQ_STATUS_UPDATE:
5407                 if (!stage_update(view, line))
5408                         return REQ_NONE;
5409                 break;
5410
5411         case REQ_STATUS_REVERT:
5412                 if (!stage_revert(view, line))
5413                         return REQ_NONE;
5414                 break;
5415
5416         case REQ_STAGE_NEXT:
5417                 if (stage_line_type == LINE_STAT_UNTRACKED) {
5418                         report("File is untracked; press %s to add",
5419                                get_key(REQ_STATUS_UPDATE));
5420                         return REQ_NONE;
5421                 }
5422                 stage_next(view, line);
5423                 return REQ_NONE;
5424
5425         case REQ_EDIT:
5426                 if (!stage_status.new.name[0])
5427                         return request;
5428                 if (stage_status.status == 'D') {
5429                         report("File has been deleted.");
5430                         return REQ_NONE;
5431                 }
5432
5433                 open_editor(stage_status.status != '?', stage_status.new.name);
5434                 break;
5435
5436         case REQ_REFRESH:
5437                 /* Reload everything ... */
5438                 break;
5439
5440         case REQ_VIEW_BLAME:
5441                 if (stage_status.new.name[0]) {
5442                         string_copy(opt_file, stage_status.new.name);
5443                         opt_ref[0] = 0;
5444                 }
5445                 return request;
5446
5447         case REQ_ENTER:
5448                 return pager_request(view, request, line);
5449
5450         default:
5451                 return request;
5452         }
5453
5454         VIEW(REQ_VIEW_STATUS)->p_restore = TRUE;
5455         open_view(view, REQ_VIEW_STATUS, OPEN_RELOAD | OPEN_NOMAXIMIZE);
5456
5457         /* Check whether the staged entry still exists, and close the
5458          * stage view if it doesn't. */
5459         if (!status_exists(&stage_status, stage_line_type)) {
5460                 status_restore(VIEW(REQ_VIEW_STATUS));
5461                 return REQ_VIEW_CLOSE;
5462         }
5463
5464         if (stage_line_type == LINE_STAT_UNTRACKED) {
5465                 if (!suffixcmp(stage_status.new.name, -1, "/")) {
5466                         report("Cannot display a directory");
5467                         return REQ_NONE;
5468                 }
5469
5470                 if (!prepare_update_file(view, stage_status.new.name)) {
5471                         report("Failed to open file: %s", strerror(errno));
5472                         return REQ_NONE;
5473                 }
5474         }
5475         open_view(view, REQ_VIEW_STAGE, OPEN_REFRESH);
5476
5477         return REQ_NONE;
5478 }
5479
5480 static struct view_ops stage_ops = {
5481         "line",
5482         NULL,
5483         NULL,
5484         pager_read,
5485         pager_draw,
5486         stage_request,
5487         pager_grep,
5488         pager_select,
5489 };
5490
5491
5492 /*
5493  * Revision graph
5494  */
5495
5496 struct commit {
5497         char id[SIZEOF_REV];            /* SHA1 ID. */
5498         char title[128];                /* First line of the commit message. */
5499         char author[75];                /* Author of the commit. */
5500         struct tm time;                 /* Date from the author ident. */
5501         struct ref **refs;              /* Repository references. */
5502         chtype graph[SIZEOF_REVGRAPH];  /* Ancestry chain graphics. */
5503         size_t graph_size;              /* The width of the graph array. */
5504         bool has_parents;               /* Rewritten --parents seen. */
5505 };
5506
5507 /* Size of rev graph with no  "padding" columns */
5508 #define SIZEOF_REVITEMS (SIZEOF_REVGRAPH - (SIZEOF_REVGRAPH / 2))
5509
5510 struct rev_graph {
5511         struct rev_graph *prev, *next, *parents;
5512         char rev[SIZEOF_REVITEMS][SIZEOF_REV];
5513         size_t size;
5514         struct commit *commit;
5515         size_t pos;
5516         unsigned int boundary:1;
5517 };
5518
5519 /* Parents of the commit being visualized. */
5520 static struct rev_graph graph_parents[4];
5521
5522 /* The current stack of revisions on the graph. */
5523 static struct rev_graph graph_stacks[4] = {
5524         { &graph_stacks[3], &graph_stacks[1], &graph_parents[0] },
5525         { &graph_stacks[0], &graph_stacks[2], &graph_parents[1] },
5526         { &graph_stacks[1], &graph_stacks[3], &graph_parents[2] },
5527         { &graph_stacks[2], &graph_stacks[0], &graph_parents[3] },
5528 };
5529
5530 static inline bool
5531 graph_parent_is_merge(struct rev_graph *graph)
5532 {
5533         return graph->parents->size > 1;
5534 }
5535
5536 static inline void
5537 append_to_rev_graph(struct rev_graph *graph, chtype symbol)
5538 {
5539         struct commit *commit = graph->commit;
5540
5541         if (commit->graph_size < ARRAY_SIZE(commit->graph) - 1)
5542                 commit->graph[commit->graph_size++] = symbol;
5543 }
5544
5545 static void
5546 clear_rev_graph(struct rev_graph *graph)
5547 {
5548         graph->boundary = 0;
5549         graph->size = graph->pos = 0;
5550         graph->commit = NULL;
5551         memset(graph->parents, 0, sizeof(*graph->parents));
5552 }
5553
5554 static void
5555 done_rev_graph(struct rev_graph *graph)
5556 {
5557         if (graph_parent_is_merge(graph) &&
5558             graph->pos < graph->size - 1 &&
5559             graph->next->size == graph->size + graph->parents->size - 1) {
5560                 size_t i = graph->pos + graph->parents->size - 1;
5561
5562                 graph->commit->graph_size = i * 2;
5563                 while (i < graph->next->size - 1) {
5564                         append_to_rev_graph(graph, ' ');
5565                         append_to_rev_graph(graph, '\\');
5566                         i++;
5567                 }
5568         }
5569
5570         clear_rev_graph(graph);
5571 }
5572
5573 static void
5574 push_rev_graph(struct rev_graph *graph, const char *parent)
5575 {
5576         int i;
5577
5578         /* "Collapse" duplicate parents lines.
5579          *
5580          * FIXME: This needs to also update update the drawn graph but
5581          * for now it just serves as a method for pruning graph lines. */
5582         for (i = 0; i < graph->size; i++)
5583                 if (!strncmp(graph->rev[i], parent, SIZEOF_REV))
5584                         return;
5585
5586         if (graph->size < SIZEOF_REVITEMS) {
5587                 string_copy_rev(graph->rev[graph->size++], parent);
5588         }
5589 }
5590
5591 static chtype
5592 get_rev_graph_symbol(struct rev_graph *graph)
5593 {
5594         chtype symbol;
5595
5596         if (graph->boundary)
5597                 symbol = REVGRAPH_BOUND;
5598         else if (graph->parents->size == 0)
5599                 symbol = REVGRAPH_INIT;
5600         else if (graph_parent_is_merge(graph))
5601                 symbol = REVGRAPH_MERGE;
5602         else if (graph->pos >= graph->size)
5603                 symbol = REVGRAPH_BRANCH;
5604         else
5605                 symbol = REVGRAPH_COMMIT;
5606
5607         return symbol;
5608 }
5609
5610 static void
5611 draw_rev_graph(struct rev_graph *graph)
5612 {
5613         struct rev_filler {
5614                 chtype separator, line;
5615         };
5616         enum { DEFAULT, RSHARP, RDIAG, LDIAG };
5617         static struct rev_filler fillers[] = {
5618                 { ' ',  '|' },
5619                 { '`',  '.' },
5620                 { '\'', ' ' },
5621                 { '/',  ' ' },
5622         };
5623         chtype symbol = get_rev_graph_symbol(graph);
5624         struct rev_filler *filler;
5625         size_t i;
5626
5627         if (opt_line_graphics)
5628                 fillers[DEFAULT].line = line_graphics[LINE_GRAPHIC_VLINE];
5629
5630         filler = &fillers[DEFAULT];
5631
5632         for (i = 0; i < graph->pos; i++) {
5633                 append_to_rev_graph(graph, filler->line);
5634                 if (graph_parent_is_merge(graph->prev) &&
5635                     graph->prev->pos == i)
5636                         filler = &fillers[RSHARP];
5637
5638                 append_to_rev_graph(graph, filler->separator);
5639         }
5640
5641         /* Place the symbol for this revision. */
5642         append_to_rev_graph(graph, symbol);
5643
5644         if (graph->prev->size > graph->size)
5645                 filler = &fillers[RDIAG];
5646         else
5647                 filler = &fillers[DEFAULT];
5648
5649         i++;
5650
5651         for (; i < graph->size; i++) {
5652                 append_to_rev_graph(graph, filler->separator);
5653                 append_to_rev_graph(graph, filler->line);
5654                 if (graph_parent_is_merge(graph->prev) &&
5655                     i < graph->prev->pos + graph->parents->size)
5656                         filler = &fillers[RSHARP];
5657                 if (graph->prev->size > graph->size)
5658                         filler = &fillers[LDIAG];
5659         }
5660
5661         if (graph->prev->size > graph->size) {
5662                 append_to_rev_graph(graph, filler->separator);
5663                 if (filler->line != ' ')
5664                         append_to_rev_graph(graph, filler->line);
5665         }
5666 }
5667
5668 /* Prepare the next rev graph */
5669 static void
5670 prepare_rev_graph(struct rev_graph *graph)
5671 {
5672         size_t i;
5673
5674         /* First, traverse all lines of revisions up to the active one. */
5675         for (graph->pos = 0; graph->pos < graph->size; graph->pos++) {
5676                 if (!strcmp(graph->rev[graph->pos], graph->commit->id))
5677                         break;
5678
5679                 push_rev_graph(graph->next, graph->rev[graph->pos]);
5680         }
5681
5682         /* Interleave the new revision parent(s). */
5683         for (i = 0; !graph->boundary && i < graph->parents->size; i++)
5684                 push_rev_graph(graph->next, graph->parents->rev[i]);
5685
5686         /* Lastly, put any remaining revisions. */
5687         for (i = graph->pos + 1; i < graph->size; i++)
5688                 push_rev_graph(graph->next, graph->rev[i]);
5689 }
5690
5691 static void
5692 update_rev_graph(struct view *view, struct rev_graph *graph)
5693 {
5694         /* If this is the finalizing update ... */
5695         if (graph->commit)
5696                 prepare_rev_graph(graph);
5697
5698         /* Graph visualization needs a one rev look-ahead,
5699          * so the first update doesn't visualize anything. */
5700         if (!graph->prev->commit)
5701                 return;
5702
5703         if (view->lines > 2)
5704                 view->line[view->lines - 3].dirty = 1;
5705         if (view->lines > 1)
5706                 view->line[view->lines - 2].dirty = 1;
5707         draw_rev_graph(graph->prev);
5708         done_rev_graph(graph->prev->prev);
5709 }
5710
5711
5712 /*
5713  * Main view backend
5714  */
5715
5716 static const char *main_argv[SIZEOF_ARG] = {
5717         "git", "log", "--no-color", "--pretty=raw", "--parents",
5718                       "--topo-order", "%(head)", NULL
5719 };
5720
5721 static bool
5722 main_draw(struct view *view, struct line *line, unsigned int lineno)
5723 {
5724         struct commit *commit = line->data;
5725
5726         if (!*commit->author)
5727                 return FALSE;
5728
5729         if (opt_date && draw_date(view, &commit->time))
5730                 return TRUE;
5731
5732         if (opt_author && draw_author(view, commit->author))
5733                 return TRUE;
5734
5735         if (opt_rev_graph && commit->graph_size &&
5736             draw_graphic(view, LINE_MAIN_REVGRAPH, commit->graph, commit->graph_size))
5737                 return TRUE;
5738
5739         if (opt_show_refs && commit->refs) {
5740                 size_t i = 0;
5741
5742                 do {
5743                         enum line_type type;
5744
5745                         if (commit->refs[i]->head)
5746                                 type = LINE_MAIN_HEAD;
5747                         else if (commit->refs[i]->ltag)
5748                                 type = LINE_MAIN_LOCAL_TAG;
5749                         else if (commit->refs[i]->tag)
5750                                 type = LINE_MAIN_TAG;
5751                         else if (commit->refs[i]->tracked)
5752                                 type = LINE_MAIN_TRACKED;
5753                         else if (commit->refs[i]->remote)
5754                                 type = LINE_MAIN_REMOTE;
5755                         else
5756                                 type = LINE_MAIN_REF;
5757
5758                         if (draw_text(view, type, "[", TRUE) ||
5759                             draw_text(view, type, commit->refs[i]->name, TRUE) ||
5760                             draw_text(view, type, "]", TRUE))
5761                                 return TRUE;
5762
5763                         if (draw_text(view, LINE_DEFAULT, " ", TRUE))
5764                                 return TRUE;
5765                 } while (commit->refs[i++]->next);
5766         }
5767
5768         draw_text(view, LINE_DEFAULT, commit->title, TRUE);
5769         return TRUE;
5770 }
5771
5772 /* Reads git log --pretty=raw output and parses it into the commit struct. */
5773 static bool
5774 main_read(struct view *view, char *line)
5775 {
5776         static struct rev_graph *graph = graph_stacks;
5777         enum line_type type;
5778         struct commit *commit;
5779
5780         if (!line) {
5781                 int i;
5782
5783                 if (!view->lines && !view->parent)
5784                         die("No revisions match the given arguments.");
5785                 if (view->lines > 0) {
5786                         commit = view->line[view->lines - 1].data;
5787                         view->line[view->lines - 1].dirty = 1;
5788                         if (!*commit->author) {
5789                                 view->lines--;
5790                                 free(commit);
5791                                 graph->commit = NULL;
5792                         }
5793                 }
5794                 update_rev_graph(view, graph);
5795
5796                 for (i = 0; i < ARRAY_SIZE(graph_stacks); i++)
5797                         clear_rev_graph(&graph_stacks[i]);
5798                 return TRUE;
5799         }
5800
5801         type = get_line_type(line);
5802         if (type == LINE_COMMIT) {
5803                 commit = calloc(1, sizeof(struct commit));
5804                 if (!commit)
5805                         return FALSE;
5806
5807                 line += STRING_SIZE("commit ");
5808                 if (*line == '-') {
5809                         graph->boundary = 1;
5810                         line++;
5811                 }
5812
5813                 string_copy_rev(commit->id, line);
5814                 commit->refs = get_refs(commit->id);
5815                 graph->commit = commit;
5816                 add_line_data(view, commit, LINE_MAIN_COMMIT);
5817
5818                 while ((line = strchr(line, ' '))) {
5819                         line++;
5820                         push_rev_graph(graph->parents, line);
5821                         commit->has_parents = TRUE;
5822                 }
5823                 return TRUE;
5824         }
5825
5826         if (!view->lines)
5827                 return TRUE;
5828         commit = view->line[view->lines - 1].data;
5829
5830         switch (type) {
5831         case LINE_PARENT:
5832                 if (commit->has_parents)
5833                         break;
5834                 push_rev_graph(graph->parents, line + STRING_SIZE("parent "));
5835                 break;
5836
5837         case LINE_AUTHOR:
5838                 parse_author_line(line + STRING_SIZE("author "),
5839                                   commit->author, sizeof(commit->author),
5840                                   &commit->time);
5841                 update_rev_graph(view, graph);
5842                 graph = graph->next;
5843                 break;
5844
5845         default:
5846                 /* Fill in the commit title if it has not already been set. */
5847                 if (commit->title[0])
5848                         break;
5849
5850                 /* Require titles to start with a non-space character at the
5851                  * offset used by git log. */
5852                 if (strncmp(line, "    ", 4))
5853                         break;
5854                 line += 4;
5855                 /* Well, if the title starts with a whitespace character,
5856                  * try to be forgiving.  Otherwise we end up with no title. */
5857                 while (isspace(*line))
5858                         line++;
5859                 if (*line == '\0')
5860                         break;
5861                 /* FIXME: More graceful handling of titles; append "..." to
5862                  * shortened titles, etc. */
5863
5864                 string_expand(commit->title, sizeof(commit->title), line, 1);
5865                 view->line[view->lines - 1].dirty = 1;
5866         }
5867
5868         return TRUE;
5869 }
5870
5871 static enum request
5872 main_request(struct view *view, enum request request, struct line *line)
5873 {
5874         enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
5875
5876         switch (request) {
5877         case REQ_ENTER:
5878                 open_view(view, REQ_VIEW_DIFF, flags);
5879                 break;
5880         case REQ_REFRESH:
5881                 load_refs();
5882                 open_view(view, REQ_VIEW_MAIN, OPEN_REFRESH);
5883                 break;
5884         default:
5885                 return request;
5886         }
5887
5888         return REQ_NONE;
5889 }
5890
5891 static bool
5892 grep_refs(struct ref **refs, regex_t *regex)
5893 {
5894         regmatch_t pmatch;
5895         size_t i = 0;
5896
5897         if (!refs)
5898                 return FALSE;
5899         do {
5900                 if (regexec(regex, refs[i]->name, 1, &pmatch, 0) != REG_NOMATCH)
5901                         return TRUE;
5902         } while (refs[i++]->next);
5903
5904         return FALSE;
5905 }
5906
5907 static bool
5908 main_grep(struct view *view, struct line *line)
5909 {
5910         struct commit *commit = line->data;
5911         enum { S_TITLE, S_AUTHOR, S_DATE, S_REFS, S_END } state;
5912         char buf[DATE_COLS + 1];
5913         regmatch_t pmatch;
5914
5915         for (state = S_TITLE; state < S_END; state++) {
5916                 char *text;
5917
5918                 switch (state) {
5919                 case S_TITLE:   text = commit->title;   break;
5920                 case S_AUTHOR:
5921                         if (!opt_author)
5922                                 continue;
5923                         text = commit->author;
5924                         break;
5925                 case S_DATE:
5926                         if (!opt_date)
5927                                 continue;
5928                         if (!strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time))
5929                                 continue;
5930                         text = buf;
5931                         break;
5932                 case S_REFS:
5933                         if (!opt_show_refs)
5934                                 continue;
5935                         if (grep_refs(commit->refs, view->regex) == TRUE)
5936                                 return TRUE;
5937                         continue;
5938                 default:
5939                         return FALSE;
5940                 }
5941
5942                 if (regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
5943                         return TRUE;
5944         }
5945
5946         return FALSE;
5947 }
5948
5949 static void
5950 main_select(struct view *view, struct line *line)
5951 {
5952         struct commit *commit = line->data;
5953
5954         string_copy_rev(view->ref, commit->id);
5955         string_copy_rev(ref_commit, view->ref);
5956 }
5957
5958 static struct view_ops main_ops = {
5959         "commit",
5960         main_argv,
5961         NULL,
5962         main_read,
5963         main_draw,
5964         main_request,
5965         main_grep,
5966         main_select,
5967 };
5968
5969
5970 /*
5971  * Unicode / UTF-8 handling
5972  *
5973  * NOTE: Much of the following code for dealing with Unicode is derived from
5974  * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
5975  * src/intl/charset.c from the UTF-8 branch commit elinks-0.11.0-g31f2c28.
5976  */
5977
5978 static inline int
5979 unicode_width(unsigned long c)
5980 {
5981         if (c >= 0x1100 &&
5982            (c <= 0x115f                         /* Hangul Jamo */
5983             || c == 0x2329
5984             || c == 0x232a
5985             || (c >= 0x2e80  && c <= 0xa4cf && c != 0x303f)
5986                                                 /* CJK ... Yi */
5987             || (c >= 0xac00  && c <= 0xd7a3)    /* Hangul Syllables */
5988             || (c >= 0xf900  && c <= 0xfaff)    /* CJK Compatibility Ideographs */
5989             || (c >= 0xfe30  && c <= 0xfe6f)    /* CJK Compatibility Forms */
5990             || (c >= 0xff00  && c <= 0xff60)    /* Fullwidth Forms */
5991             || (c >= 0xffe0  && c <= 0xffe6)
5992             || (c >= 0x20000 && c <= 0x2fffd)
5993             || (c >= 0x30000 && c <= 0x3fffd)))
5994                 return 2;
5995
5996         if (c == '\t')
5997                 return opt_tab_size;
5998
5999         return 1;
6000 }
6001
6002 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
6003  * Illegal bytes are set one. */
6004 static const unsigned char utf8_bytes[256] = {
6005         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,
6006         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,
6007         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,
6008         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,
6009         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,
6010         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,
6011         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,
6012         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,
6013 };
6014
6015 /* Decode UTF-8 multi-byte representation into a Unicode character. */
6016 static inline unsigned long
6017 utf8_to_unicode(const char *string, size_t length)
6018 {
6019         unsigned long unicode;
6020
6021         switch (length) {
6022         case 1:
6023                 unicode  =   string[0];
6024                 break;
6025         case 2:
6026                 unicode  =  (string[0] & 0x1f) << 6;
6027                 unicode +=  (string[1] & 0x3f);
6028                 break;
6029         case 3:
6030                 unicode  =  (string[0] & 0x0f) << 12;
6031                 unicode += ((string[1] & 0x3f) << 6);
6032                 unicode +=  (string[2] & 0x3f);
6033                 break;
6034         case 4:
6035                 unicode  =  (string[0] & 0x0f) << 18;
6036                 unicode += ((string[1] & 0x3f) << 12);
6037                 unicode += ((string[2] & 0x3f) << 6);
6038                 unicode +=  (string[3] & 0x3f);
6039                 break;
6040         case 5:
6041                 unicode  =  (string[0] & 0x0f) << 24;
6042                 unicode += ((string[1] & 0x3f) << 18);
6043                 unicode += ((string[2] & 0x3f) << 12);
6044                 unicode += ((string[3] & 0x3f) << 6);
6045                 unicode +=  (string[4] & 0x3f);
6046                 break;
6047         case 6:
6048                 unicode  =  (string[0] & 0x01) << 30;
6049                 unicode += ((string[1] & 0x3f) << 24);
6050                 unicode += ((string[2] & 0x3f) << 18);
6051                 unicode += ((string[3] & 0x3f) << 12);
6052                 unicode += ((string[4] & 0x3f) << 6);
6053                 unicode +=  (string[5] & 0x3f);
6054                 break;
6055         default:
6056                 die("Invalid Unicode length");
6057         }
6058
6059         /* Invalid characters could return the special 0xfffd value but NUL
6060          * should be just as good. */
6061         return unicode > 0xffff ? 0 : unicode;
6062 }
6063
6064 /* Calculates how much of string can be shown within the given maximum width
6065  * and sets trimmed parameter to non-zero value if all of string could not be
6066  * shown. If the reserve flag is TRUE, it will reserve at least one
6067  * trailing character, which can be useful when drawing a delimiter.
6068  *
6069  * Returns the number of bytes to output from string to satisfy max_width. */
6070 static size_t
6071 utf8_length(const char **start, size_t skip, int *width, size_t max_width, int *trimmed, bool reserve)
6072 {
6073         const char *string = *start;
6074         const char *end = strchr(string, '\0');
6075         unsigned char last_bytes = 0;
6076         size_t last_ucwidth = 0;
6077
6078         *width = 0;
6079         *trimmed = 0;
6080
6081         while (string < end) {
6082                 int c = *(unsigned char *) string;
6083                 unsigned char bytes = utf8_bytes[c];
6084                 size_t ucwidth;
6085                 unsigned long unicode;
6086
6087                 if (string + bytes > end)
6088                         break;
6089
6090                 /* Change representation to figure out whether
6091                  * it is a single- or double-width character. */
6092
6093                 unicode = utf8_to_unicode(string, bytes);
6094                 /* FIXME: Graceful handling of invalid Unicode character. */
6095                 if (!unicode)
6096                         break;
6097
6098                 ucwidth = unicode_width(unicode);
6099                 if (skip > 0) {
6100                         skip -= ucwidth <= skip ? ucwidth : skip;
6101                         *start += bytes;
6102                 }
6103                 *width  += ucwidth;
6104                 if (*width > max_width) {
6105                         *trimmed = 1;
6106                         *width -= ucwidth;
6107                         if (reserve && *width == max_width) {
6108                                 string -= last_bytes;
6109                                 *width -= last_ucwidth;
6110                         }
6111                         break;
6112                 }
6113
6114                 string  += bytes;
6115                 last_bytes = ucwidth ? bytes : 0;
6116                 last_ucwidth = ucwidth;
6117         }
6118
6119         return string - *start;
6120 }
6121
6122
6123 /*
6124  * Status management
6125  */
6126
6127 /* Whether or not the curses interface has been initialized. */
6128 static bool cursed = FALSE;
6129
6130 /* Terminal hacks and workarounds. */
6131 static bool use_scroll_redrawwin;
6132 static bool use_scroll_status_wclear;
6133
6134 /* The status window is used for polling keystrokes. */
6135 static WINDOW *status_win;
6136
6137 /* Reading from the prompt? */
6138 static bool input_mode = FALSE;
6139
6140 static bool status_empty = FALSE;
6141
6142 /* Update status and title window. */
6143 static void
6144 report(const char *msg, ...)
6145 {
6146         struct view *view = display[current_view];
6147
6148         if (input_mode)
6149                 return;
6150
6151         if (!view) {
6152                 char buf[SIZEOF_STR];
6153                 va_list args;
6154
6155                 va_start(args, msg);
6156                 if (vsnprintf(buf, sizeof(buf), msg, args) >= sizeof(buf)) {
6157                         buf[sizeof(buf) - 1] = 0;
6158                         buf[sizeof(buf) - 2] = '.';
6159                         buf[sizeof(buf) - 3] = '.';
6160                         buf[sizeof(buf) - 4] = '.';
6161                 }
6162                 va_end(args);
6163                 die("%s", buf);
6164         }
6165
6166         if (!status_empty || *msg) {
6167                 va_list args;
6168
6169                 va_start(args, msg);
6170
6171                 wmove(status_win, 0, 0);
6172                 if (view->has_scrolled && use_scroll_status_wclear)
6173                         wclear(status_win);
6174                 if (*msg) {
6175                         vwprintw(status_win, msg, args);
6176                         status_empty = FALSE;
6177                 } else {
6178                         status_empty = TRUE;
6179                 }
6180                 wclrtoeol(status_win);
6181                 wnoutrefresh(status_win);
6182
6183                 va_end(args);
6184         }
6185
6186         update_view_title(view);
6187 }
6188
6189 /* Controls when nodelay should be in effect when polling user input. */
6190 static void
6191 set_nonblocking_input(bool loading)
6192 {
6193         static unsigned int loading_views;
6194
6195         if ((loading == FALSE && loading_views-- == 1) ||
6196             (loading == TRUE  && loading_views++ == 0))
6197                 nodelay(status_win, loading);
6198 }
6199
6200 static void
6201 init_display(void)
6202 {
6203         const char *term;
6204         int x, y;
6205
6206         /* Initialize the curses library */
6207         if (isatty(STDIN_FILENO)) {
6208                 cursed = !!initscr();
6209                 opt_tty = stdin;
6210         } else {
6211                 /* Leave stdin and stdout alone when acting as a pager. */
6212                 opt_tty = fopen("/dev/tty", "r+");
6213                 if (!opt_tty)
6214                         die("Failed to open /dev/tty");
6215                 cursed = !!newterm(NULL, opt_tty, opt_tty);
6216         }
6217
6218         if (!cursed)
6219                 die("Failed to initialize curses");
6220
6221         nonl();         /* Disable conversion and detect newlines from input. */
6222         cbreak();       /* Take input chars one at a time, no wait for \n */
6223         noecho();       /* Don't echo input */
6224         leaveok(stdscr, FALSE);
6225
6226         if (has_colors())
6227                 init_colors();
6228
6229         getmaxyx(stdscr, y, x);
6230         status_win = newwin(1, 0, y - 1, 0);
6231         if (!status_win)
6232                 die("Failed to create status window");
6233
6234         /* Enable keyboard mapping */
6235         keypad(status_win, TRUE);
6236         wbkgdset(status_win, get_line_attr(LINE_STATUS));
6237
6238         TABSIZE = opt_tab_size;
6239         if (opt_line_graphics) {
6240                 line_graphics[LINE_GRAPHIC_VLINE] = ACS_VLINE;
6241         }
6242
6243         term = getenv("XTERM_VERSION") ? NULL : getenv("COLORTERM");
6244         if (term && !strcmp(term, "gnome-terminal")) {
6245                 /* In the gnome-terminal-emulator, the message from
6246                  * scrolling up one line when impossible followed by
6247                  * scrolling down one line causes corruption of the
6248                  * status line. This is fixed by calling wclear. */
6249                 use_scroll_status_wclear = TRUE;
6250                 use_scroll_redrawwin = FALSE;
6251
6252         } else if (term && !strcmp(term, "xrvt-xpm")) {
6253                 /* No problems with full optimizations in xrvt-(unicode)
6254                  * and aterm. */
6255                 use_scroll_status_wclear = use_scroll_redrawwin = FALSE;
6256
6257         } else {
6258                 /* When scrolling in (u)xterm the last line in the
6259                  * scrolling direction will update slowly. */
6260                 use_scroll_redrawwin = TRUE;
6261                 use_scroll_status_wclear = FALSE;
6262         }
6263 }
6264
6265 static int
6266 get_input(int prompt_position)
6267 {
6268         struct view *view;
6269         int i, key, cursor_y, cursor_x;
6270
6271         if (prompt_position)
6272                 input_mode = TRUE;
6273
6274         while (TRUE) {
6275                 foreach_view (view, i) {
6276                         update_view(view);
6277                         if (view_is_displayed(view) && view->has_scrolled &&
6278                             use_scroll_redrawwin)
6279                                 redrawwin(view->win);
6280                         view->has_scrolled = FALSE;
6281                 }
6282
6283                 /* Update the cursor position. */
6284                 if (prompt_position) {
6285                         getbegyx(status_win, cursor_y, cursor_x);
6286                         cursor_x = prompt_position;
6287                 } else {
6288                         view = display[current_view];
6289                         getbegyx(view->win, cursor_y, cursor_x);
6290                         cursor_x = view->width - 1;
6291                         cursor_y += view->lineno - view->offset;
6292                 }
6293                 setsyx(cursor_y, cursor_x);
6294
6295                 /* Refresh, accept single keystroke of input */
6296                 doupdate();
6297                 key = wgetch(status_win);
6298
6299                 /* wgetch() with nodelay() enabled returns ERR when
6300                  * there's no input. */
6301                 if (key == ERR) {
6302
6303                 } else if (key == KEY_RESIZE) {
6304                         int height, width;
6305
6306                         getmaxyx(stdscr, height, width);
6307
6308                         wresize(status_win, 1, width);
6309                         mvwin(status_win, height - 1, 0);
6310                         wnoutrefresh(status_win);
6311                         resize_display();
6312                         redraw_display(TRUE);
6313
6314                 } else {
6315                         input_mode = FALSE;
6316                         return key;
6317                 }
6318         }
6319 }
6320
6321 static char *
6322 prompt_input(const char *prompt, input_handler handler, void *data)
6323 {
6324         enum input_status status = INPUT_OK;
6325         static char buf[SIZEOF_STR];
6326         size_t pos = 0;
6327
6328         buf[pos] = 0;
6329
6330         while (status == INPUT_OK || status == INPUT_SKIP) {
6331                 int key;
6332
6333                 mvwprintw(status_win, 0, 0, "%s%.*s", prompt, pos, buf);
6334                 wclrtoeol(status_win);
6335
6336                 key = get_input(pos + 1);
6337                 switch (key) {
6338                 case KEY_RETURN:
6339                 case KEY_ENTER:
6340                 case '\n':
6341                         status = pos ? INPUT_STOP : INPUT_CANCEL;
6342                         break;
6343
6344                 case KEY_BACKSPACE:
6345                         if (pos > 0)
6346                                 buf[--pos] = 0;
6347                         else
6348                                 status = INPUT_CANCEL;
6349                         break;
6350
6351                 case KEY_ESC:
6352                         status = INPUT_CANCEL;
6353                         break;
6354
6355                 default:
6356                         if (pos >= sizeof(buf)) {
6357                                 report("Input string too long");
6358                                 return NULL;
6359                         }
6360
6361                         status = handler(data, buf, key);
6362                         if (status == INPUT_OK)
6363                                 buf[pos++] = (char) key;
6364                 }
6365         }
6366
6367         /* Clear the status window */
6368         status_empty = FALSE;
6369         report("");
6370
6371         if (status == INPUT_CANCEL)
6372                 return NULL;
6373
6374         buf[pos++] = 0;
6375
6376         return buf;
6377 }
6378
6379 static enum input_status
6380 prompt_yesno_handler(void *data, char *buf, int c)
6381 {
6382         if (c == 'y' || c == 'Y')
6383                 return INPUT_STOP;
6384         if (c == 'n' || c == 'N')
6385                 return INPUT_CANCEL;
6386         return INPUT_SKIP;
6387 }
6388
6389 static bool
6390 prompt_yesno(const char *prompt)
6391 {
6392         char prompt2[SIZEOF_STR];
6393
6394         if (!string_format(prompt2, "%s [Yy/Nn]", prompt))
6395                 return FALSE;
6396
6397         return !!prompt_input(prompt2, prompt_yesno_handler, NULL);
6398 }
6399
6400 static enum input_status
6401 read_prompt_handler(void *data, char *buf, int c)
6402 {
6403         return isprint(c) ? INPUT_OK : INPUT_SKIP;
6404 }
6405
6406 static char *
6407 read_prompt(const char *prompt)
6408 {
6409         return prompt_input(prompt, read_prompt_handler, NULL);
6410 }
6411
6412 /*
6413  * Repository properties
6414  */
6415
6416 static struct ref *refs = NULL;
6417 static size_t refs_alloc = 0;
6418 static size_t refs_size = 0;
6419
6420 /* Id <-> ref store */
6421 static struct ref ***id_refs = NULL;
6422 static size_t id_refs_alloc = 0;
6423 static size_t id_refs_size = 0;
6424
6425 static int
6426 compare_refs(const void *ref1_, const void *ref2_)
6427 {
6428         const struct ref *ref1 = *(const struct ref **)ref1_;
6429         const struct ref *ref2 = *(const struct ref **)ref2_;
6430
6431         if (ref1->tag != ref2->tag)
6432                 return ref2->tag - ref1->tag;
6433         if (ref1->ltag != ref2->ltag)
6434                 return ref2->ltag - ref2->ltag;
6435         if (ref1->head != ref2->head)
6436                 return ref2->head - ref1->head;
6437         if (ref1->tracked != ref2->tracked)
6438                 return ref2->tracked - ref1->tracked;
6439         if (ref1->remote != ref2->remote)
6440                 return ref2->remote - ref1->remote;
6441         return strcmp(ref1->name, ref2->name);
6442 }
6443
6444 static struct ref **
6445 get_refs(const char *id)
6446 {
6447         struct ref ***tmp_id_refs;
6448         struct ref **ref_list = NULL;
6449         size_t ref_list_alloc = 0;
6450         size_t ref_list_size = 0;
6451         size_t i;
6452
6453         for (i = 0; i < id_refs_size; i++)
6454                 if (!strcmp(id, id_refs[i][0]->id))
6455                         return id_refs[i];
6456
6457         tmp_id_refs = realloc_items(id_refs, &id_refs_alloc, id_refs_size + 1,
6458                                     sizeof(*id_refs));
6459         if (!tmp_id_refs)
6460                 return NULL;
6461
6462         id_refs = tmp_id_refs;
6463
6464         for (i = 0; i < refs_size; i++) {
6465                 struct ref **tmp;
6466
6467                 if (strcmp(id, refs[i].id))
6468                         continue;
6469
6470                 tmp = realloc_items(ref_list, &ref_list_alloc,
6471                                     ref_list_size + 1, sizeof(*ref_list));
6472                 if (!tmp) {
6473                         if (ref_list)
6474                                 free(ref_list);
6475                         return NULL;
6476                 }
6477
6478                 ref_list = tmp;
6479                 ref_list[ref_list_size] = &refs[i];
6480                 /* XXX: The properties of the commit chains ensures that we can
6481                  * safely modify the shared ref. The repo references will
6482                  * always be similar for the same id. */
6483                 ref_list[ref_list_size]->next = 1;
6484
6485                 ref_list_size++;
6486         }
6487
6488         if (ref_list) {
6489                 qsort(ref_list, ref_list_size, sizeof(*ref_list), compare_refs);
6490                 ref_list[ref_list_size - 1]->next = 0;
6491                 id_refs[id_refs_size++] = ref_list;
6492         }
6493
6494         return ref_list;
6495 }
6496
6497 static int
6498 read_ref(char *id, size_t idlen, char *name, size_t namelen)
6499 {
6500         struct ref *ref;
6501         bool tag = FALSE;
6502         bool ltag = FALSE;
6503         bool remote = FALSE;
6504         bool tracked = FALSE;
6505         bool check_replace = FALSE;
6506         bool head = FALSE;
6507
6508         if (!prefixcmp(name, "refs/tags/")) {
6509                 if (!suffixcmp(name, namelen, "^{}")) {
6510                         namelen -= 3;
6511                         name[namelen] = 0;
6512                         if (refs_size > 0 && refs[refs_size - 1].ltag == TRUE)
6513                                 check_replace = TRUE;
6514                 } else {
6515                         ltag = TRUE;
6516                 }
6517
6518                 tag = TRUE;
6519                 namelen -= STRING_SIZE("refs/tags/");
6520                 name    += STRING_SIZE("refs/tags/");
6521
6522         } else if (!prefixcmp(name, "refs/remotes/")) {
6523                 remote = TRUE;
6524                 namelen -= STRING_SIZE("refs/remotes/");
6525                 name    += STRING_SIZE("refs/remotes/");
6526                 tracked  = !strcmp(opt_remote, name);
6527
6528         } else if (!prefixcmp(name, "refs/heads/")) {
6529                 namelen -= STRING_SIZE("refs/heads/");
6530                 name    += STRING_SIZE("refs/heads/");
6531                 head     = !strncmp(opt_head, name, namelen);
6532
6533         } else if (!strcmp(name, "HEAD")) {
6534                 string_ncopy(opt_head_rev, id, idlen);
6535                 return OK;
6536         }
6537
6538         if (check_replace && !strcmp(name, refs[refs_size - 1].name)) {
6539                 /* it's an annotated tag, replace the previous SHA1 with the
6540                  * resolved commit id; relies on the fact git-ls-remote lists
6541                  * the commit id of an annotated tag right before the commit id
6542                  * it points to. */
6543                 refs[refs_size - 1].ltag = ltag;
6544                 string_copy_rev(refs[refs_size - 1].id, id);
6545
6546                 return OK;
6547         }
6548         refs = realloc_items(refs, &refs_alloc, refs_size + 1, sizeof(*refs));
6549         if (!refs)
6550                 return ERR;
6551
6552         ref = &refs[refs_size++];
6553         ref->name = malloc(namelen + 1);
6554         if (!ref->name)
6555                 return ERR;
6556
6557         strncpy(ref->name, name, namelen);
6558         ref->name[namelen] = 0;
6559         ref->head = head;
6560         ref->tag = tag;
6561         ref->ltag = ltag;
6562         ref->remote = remote;
6563         ref->tracked = tracked;
6564         string_copy_rev(ref->id, id);
6565
6566         return OK;
6567 }
6568
6569 static int
6570 load_refs(void)
6571 {
6572         static const char *ls_remote_argv[SIZEOF_ARG] = {
6573                 "git", "ls-remote", ".", NULL
6574         };
6575         static bool init = FALSE;
6576
6577         if (!init) {
6578                 argv_from_env(ls_remote_argv, "TIG_LS_REMOTE");
6579                 init = TRUE;
6580         }
6581
6582         if (!*opt_git_dir)
6583                 return OK;
6584
6585         while (refs_size > 0)
6586                 free(refs[--refs_size].name);
6587         while (id_refs_size > 0)
6588                 free(id_refs[--id_refs_size]);
6589
6590         return run_io_load(ls_remote_argv, "\t", read_ref);
6591 }
6592
6593 static void
6594 set_repo_config_option(char *name, char *value, int (*cmd)(int, const char **))
6595 {
6596         const char *argv[SIZEOF_ARG] = { name, "=" };
6597         int argc = 1 + (cmd == option_set_command);
6598         int error = ERR;
6599
6600         if (!argv_from_string(argv, &argc, value))
6601                 config_msg = "Too many option arguments";
6602         else
6603                 error = cmd(argc, argv);
6604
6605         if (error == ERR)
6606                 warn("Option 'tig.%s': %s", name, config_msg);
6607 }
6608
6609 static int
6610 read_repo_config_option(char *name, size_t namelen, char *value, size_t valuelen)
6611 {
6612         if (!strcmp(name, "i18n.commitencoding"))
6613                 string_ncopy(opt_encoding, value, valuelen);
6614
6615         if (!strcmp(name, "core.editor"))
6616                 string_ncopy(opt_editor, value, valuelen);
6617
6618         if (!prefixcmp(name, "tig.color."))
6619                 set_repo_config_option(name + 10, value, option_color_command);
6620
6621         else if (!prefixcmp(name, "tig.bind."))
6622                 set_repo_config_option(name + 9, value, option_bind_command);
6623
6624         else if (!prefixcmp(name, "tig."))
6625                 set_repo_config_option(name + 4, value, option_set_command);
6626
6627         /* branch.<head>.remote */
6628         if (*opt_head &&
6629             !strncmp(name, "branch.", 7) &&
6630             !strncmp(name + 7, opt_head, strlen(opt_head)) &&
6631             !strcmp(name + 7 + strlen(opt_head), ".remote"))
6632                 string_ncopy(opt_remote, value, valuelen);
6633
6634         if (*opt_head && *opt_remote &&
6635             !strncmp(name, "branch.", 7) &&
6636             !strncmp(name + 7, opt_head, strlen(opt_head)) &&
6637             !strcmp(name + 7 + strlen(opt_head), ".merge")) {
6638                 size_t from = strlen(opt_remote);
6639
6640                 if (!prefixcmp(value, "refs/heads/")) {
6641                         value += STRING_SIZE("refs/heads/");
6642                         valuelen -= STRING_SIZE("refs/heads/");
6643                 }
6644
6645                 if (!string_format_from(opt_remote, &from, "/%s", value))
6646                         opt_remote[0] = 0;
6647         }
6648
6649         return OK;
6650 }
6651
6652 static int
6653 load_git_config(void)
6654 {
6655         const char *config_list_argv[] = { "git", GIT_CONFIG, "--list", NULL };
6656
6657         return run_io_load(config_list_argv, "=", read_repo_config_option);
6658 }
6659
6660 static int
6661 read_repo_info(char *name, size_t namelen, char *value, size_t valuelen)
6662 {
6663         if (!opt_git_dir[0]) {
6664                 string_ncopy(opt_git_dir, name, namelen);
6665
6666         } else if (opt_is_inside_work_tree == -1) {
6667                 /* This can be 3 different values depending on the
6668                  * version of git being used. If git-rev-parse does not
6669                  * understand --is-inside-work-tree it will simply echo
6670                  * the option else either "true" or "false" is printed.
6671                  * Default to true for the unknown case. */
6672                 opt_is_inside_work_tree = strcmp(name, "false") ? TRUE : FALSE;
6673
6674         } else if (*name == '.') {
6675                 string_ncopy(opt_cdup, name, namelen);
6676
6677         } else {
6678                 string_ncopy(opt_prefix, name, namelen);
6679         }
6680
6681         return OK;
6682 }
6683
6684 static int
6685 load_repo_info(void)
6686 {
6687         const char *head_argv[] = {
6688                 "git", "symbolic-ref", "HEAD", NULL
6689         };
6690         const char *rev_parse_argv[] = {
6691                 "git", "rev-parse", "--git-dir", "--is-inside-work-tree",
6692                         "--show-cdup", "--show-prefix", NULL
6693         };
6694
6695         if (run_io_buf(head_argv, opt_head, sizeof(opt_head))) {
6696                 chomp_string(opt_head);
6697                 if (!prefixcmp(opt_head, "refs/heads/")) {
6698                         char *offset = opt_head + STRING_SIZE("refs/heads/");
6699
6700                         memmove(opt_head, offset, strlen(offset) + 1);
6701                 }
6702         }
6703
6704         return run_io_load(rev_parse_argv, "=", read_repo_info);
6705 }
6706
6707
6708 /*
6709  * Main
6710  */
6711
6712 static const char usage[] =
6713 "tig " TIG_VERSION " (" __DATE__ ")\n"
6714 "\n"
6715 "Usage: tig        [options] [revs] [--] [paths]\n"
6716 "   or: tig show   [options] [revs] [--] [paths]\n"
6717 "   or: tig blame  [rev] path\n"
6718 "   or: tig status\n"
6719 "   or: tig <      [git command output]\n"
6720 "\n"
6721 "Options:\n"
6722 "  -v, --version   Show version and exit\n"
6723 "  -h, --help      Show help message and exit";
6724
6725 static void __NORETURN
6726 quit(int sig)
6727 {
6728         /* XXX: Restore tty modes and let the OS cleanup the rest! */
6729         if (cursed)
6730                 endwin();
6731         exit(0);
6732 }
6733
6734 static void __NORETURN
6735 die(const char *err, ...)
6736 {
6737         va_list args;
6738
6739         endwin();
6740
6741         va_start(args, err);
6742         fputs("tig: ", stderr);
6743         vfprintf(stderr, err, args);
6744         fputs("\n", stderr);
6745         va_end(args);
6746
6747         exit(1);
6748 }
6749
6750 static void
6751 warn(const char *msg, ...)
6752 {
6753         va_list args;
6754
6755         va_start(args, msg);
6756         fputs("tig warning: ", stderr);
6757         vfprintf(stderr, msg, args);
6758         fputs("\n", stderr);
6759         va_end(args);
6760 }
6761
6762 static enum request
6763 parse_options(int argc, const char *argv[])
6764 {
6765         enum request request = REQ_VIEW_MAIN;
6766         const char *subcommand;
6767         bool seen_dashdash = FALSE;
6768         /* XXX: This is vulnerable to the user overriding options
6769          * required for the main view parser. */
6770         const char *custom_argv[SIZEOF_ARG] = {
6771                 "git", "log", "--no-color", "--pretty=raw", "--parents",
6772                         "--topo-order", NULL
6773         };
6774         int i, j = 6;
6775
6776         if (!isatty(STDIN_FILENO)) {
6777                 io_open(&VIEW(REQ_VIEW_PAGER)->io, "");
6778                 return REQ_VIEW_PAGER;
6779         }
6780
6781         if (argc <= 1)
6782                 return REQ_NONE;
6783
6784         subcommand = argv[1];
6785         if (!strcmp(subcommand, "status")) {
6786                 if (argc > 2)
6787                         warn("ignoring arguments after `%s'", subcommand);
6788                 return REQ_VIEW_STATUS;
6789
6790         } else if (!strcmp(subcommand, "blame")) {
6791                 if (argc <= 2 || argc > 4)
6792                         die("invalid number of options to blame\n\n%s", usage);
6793
6794                 i = 2;
6795                 if (argc == 4) {
6796                         string_ncopy(opt_ref, argv[i], strlen(argv[i]));
6797                         i++;
6798                 }
6799
6800                 string_ncopy(opt_file, argv[i], strlen(argv[i]));
6801                 return REQ_VIEW_BLAME;
6802
6803         } else if (!strcmp(subcommand, "show")) {
6804                 request = REQ_VIEW_DIFF;
6805
6806         } else {
6807                 subcommand = NULL;
6808         }
6809
6810         if (subcommand) {
6811                 custom_argv[1] = subcommand;
6812                 j = 2;
6813         }
6814
6815         for (i = 1 + !!subcommand; i < argc; i++) {
6816                 const char *opt = argv[i];
6817
6818                 if (seen_dashdash || !strcmp(opt, "--")) {
6819                         seen_dashdash = TRUE;
6820
6821                 } else if (!strcmp(opt, "-v") || !strcmp(opt, "--version")) {
6822                         printf("tig version %s\n", TIG_VERSION);
6823                         quit(0);
6824
6825                 } else if (!strcmp(opt, "-h") || !strcmp(opt, "--help")) {
6826                         printf("%s\n", usage);
6827                         quit(0);
6828                 }
6829
6830                 custom_argv[j++] = opt;
6831                 if (j >= ARRAY_SIZE(custom_argv))
6832                         die("command too long");
6833         }
6834
6835         if (!prepare_update(VIEW(request), custom_argv, NULL, FORMAT_NONE))
6836                 die("Failed to format arguments");
6837
6838         return request;
6839 }
6840
6841 int
6842 main(int argc, const char *argv[])
6843 {
6844         enum request request = parse_options(argc, argv);
6845         struct view *view;
6846         size_t i;
6847
6848         signal(SIGINT, quit);
6849
6850         if (setlocale(LC_ALL, "")) {
6851                 char *codeset = nl_langinfo(CODESET);
6852
6853                 string_ncopy(opt_codeset, codeset, strlen(codeset));
6854         }
6855
6856         if (load_repo_info() == ERR)
6857                 die("Failed to load repo info.");
6858
6859         if (load_options() == ERR)
6860                 die("Failed to load user config.");
6861
6862         if (load_git_config() == ERR)
6863                 die("Failed to load repo config.");
6864
6865         /* Require a git repository unless when running in pager mode. */
6866         if (!opt_git_dir[0] && request != REQ_VIEW_PAGER)
6867                 die("Not a git repository");
6868
6869         if (*opt_encoding && strcasecmp(opt_encoding, "UTF-8"))
6870                 opt_utf8 = FALSE;
6871
6872         if (*opt_codeset && strcmp(opt_codeset, opt_encoding)) {
6873                 opt_iconv = iconv_open(opt_codeset, opt_encoding);
6874                 if (opt_iconv == ICONV_NONE)
6875                         die("Failed to initialize character set conversion");
6876         }
6877
6878         if (load_refs() == ERR)
6879                 die("Failed to load refs.");
6880
6881         foreach_view (view, i)
6882                 argv_from_env(view->ops->argv, view->cmd_env);
6883
6884         init_display();
6885
6886         if (request != REQ_NONE)
6887                 open_view(NULL, request, OPEN_PREPARED);
6888         request = request == REQ_NONE ? REQ_VIEW_MAIN : REQ_NONE;
6889
6890         while (view_driver(display[current_view], request)) {
6891                 int key = get_input(0);
6892
6893                 view = display[current_view];
6894                 request = get_keybinding(view->keymap, key);
6895
6896                 /* Some low-level request handling. This keeps access to
6897                  * status_win restricted. */
6898                 switch (request) {
6899                 case REQ_PROMPT:
6900                 {
6901                         char *cmd = read_prompt(":");
6902
6903                         if (cmd) {
6904                                 struct view *next = VIEW(REQ_VIEW_PAGER);
6905                                 const char *argv[SIZEOF_ARG] = { "git" };
6906                                 int argc = 1;
6907
6908                                 /* When running random commands, initially show the
6909                                  * command in the title. However, it maybe later be
6910                                  * overwritten if a commit line is selected. */
6911                                 string_ncopy(next->ref, cmd, strlen(cmd));
6912
6913                                 if (!argv_from_string(argv, &argc, cmd)) {
6914                                         report("Too many arguments");
6915                                 } else if (!prepare_update(next, argv, NULL, FORMAT_DASH)) {
6916                                         report("Failed to format command");
6917                                 } else {
6918                                         open_view(view, REQ_VIEW_PAGER, OPEN_PREPARED);
6919                                 }
6920                         }
6921
6922                         request = REQ_NONE;
6923                         break;
6924                 }
6925                 case REQ_SEARCH:
6926                 case REQ_SEARCH_BACK:
6927                 {
6928                         const char *prompt = request == REQ_SEARCH ? "/" : "?";
6929                         char *search = read_prompt(prompt);
6930
6931                         if (search)
6932                                 string_ncopy(opt_search, search, strlen(search));
6933                         else if (*opt_search)
6934                                 request = request == REQ_SEARCH ?
6935                                         REQ_FIND_NEXT :
6936                                         REQ_FIND_PREV;
6937                         else
6938                                 request = REQ_NONE;
6939                         break;
6940                 }
6941                 default:
6942                         break;
6943                 }
6944         }
6945
6946         quit(0);
6947
6948         return 0;
6949 }