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

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