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

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