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