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