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