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 /* Option and state variables. */
 861 static bool opt_date                    = TRUE;
 862 static bool opt_author                  = TRUE;
 863 static bool opt_line_number             = FALSE;
 864 static bool opt_line_graphics           = TRUE;
 865 static bool opt_rev_graph               = FALSE;
 866 static bool opt_show_refs               = TRUE;
 867 static int opt_num_interval             = NUMBER_INTERVAL;
 868 static int opt_tab_size                 = TAB_SIZE;
 869 static int opt_author_cols              = AUTHOR_COLS-1;
 870 static char opt_path[SIZEOF_STR]        = "";
 871 static char opt_file[SIZEOF_STR]        = "";
 872 static char opt_ref[SIZEOF_REF]         = "";
 873 static char opt_head[SIZEOF_REF]        = "";
 874 static char opt_head_rev[SIZEOF_REV]    = "";
 875 static char opt_remote[SIZEOF_REF]      = "";
 876 static char opt_encoding[20]            = "UTF-8";
 877 static bool opt_utf8                    = TRUE;
 878 static char opt_codeset[20]             = "UTF-8";
 879 static iconv_t opt_iconv                = ICONV_NONE;
 880 static char opt_search[SIZEOF_STR]      = "";
 881 static char opt_cdup[SIZEOF_STR]        = "";
 882 static char opt_prefix[SIZEOF_STR]      = "";
 883 static char opt_git_dir[SIZEOF_STR]     = "";
 884 static signed char opt_is_inside_work_tree      = -1; /* set to TRUE or FALSE */
 885 static char opt_editor[SIZEOF_STR]      = "";
 886 static FILE *opt_tty                    = NULL;
 887
 888 #define is_initial_commit()     (!*opt_head_rev)
 889 #define is_head_commit(rev)     (!strcmp((rev), "HEAD") || !strcmp(opt_head_rev, (rev)))
 890
 891
 892 /*
 893  * Line-oriented content detection.
 894  */
 895
 896 #define LINE_INFO \
 897 LINE(DIFF_HEADER,  "diff --git ",       COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 898 LINE(DIFF_CHUNK,   "@@",                COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
 899 LINE(DIFF_ADD,     "+",                 COLOR_GREEN,    COLOR_DEFAULT,  0), \
 900 LINE(DIFF_DEL,     "-",                 COLOR_RED,      COLOR_DEFAULT,  0), \
 901 LINE(DIFF_INDEX,        "index ",         COLOR_BLUE,   COLOR_DEFAULT,  0), \
 902 LINE(DIFF_OLDMODE,      "old file mode ", COLOR_YELLOW, COLOR_DEFAULT,  0), \
 903 LINE(DIFF_NEWMODE,      "new file mode ", COLOR_YELLOW, COLOR_DEFAULT,  0), \
 904 LINE(DIFF_COPY_FROM,    "copy from",      COLOR_YELLOW, COLOR_DEFAULT,  0), \
 905 LINE(DIFF_COPY_TO,      "copy to",        COLOR_YELLOW, COLOR_DEFAULT,  0), \
 906 LINE(DIFF_RENAME_FROM,  "rename from",    COLOR_YELLOW, COLOR_DEFAULT,  0), \
 907 LINE(DIFF_RENAME_TO,    "rename to",      COLOR_YELLOW, COLOR_DEFAULT,  0), \
 908 LINE(DIFF_SIMILARITY,   "similarity ",    COLOR_YELLOW, COLOR_DEFAULT,  0), \
 909 LINE(DIFF_DISSIMILARITY,"dissimilarity ", COLOR_YELLOW, COLOR_DEFAULT,  0), \
 910 LINE(DIFF_TREE,         "diff-tree ",     COLOR_BLUE,   COLOR_DEFAULT,  0), \
 911 LINE(PP_AUTHOR,    "Author: ",          COLOR_CYAN,     COLOR_DEFAULT,  0), \
 912 LINE(PP_COMMIT,    "Commit: ",          COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
 913 LINE(PP_MERGE,     "Merge: ",           COLOR_BLUE,     COLOR_DEFAULT,  0), \
 914 LINE(PP_DATE,      "Date:   ",          COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 915 LINE(PP_ADATE,     "AuthorDate: ",      COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 916 LINE(PP_CDATE,     "CommitDate: ",      COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 917 LINE(PP_REFS,      "Refs: ",            COLOR_RED,      COLOR_DEFAULT,  0), \
 918 LINE(COMMIT,       "commit ",           COLOR_GREEN,    COLOR_DEFAULT,  0), \
 919 LINE(PARENT,       "parent ",           COLOR_BLUE,     COLOR_DEFAULT,  0), \
 920 LINE(TREE,         "tree ",             COLOR_BLUE,     COLOR_DEFAULT,  0), \
 921 LINE(AUTHOR,       "author ",           COLOR_GREEN,    COLOR_DEFAULT,  0), \
 922 LINE(COMMITTER,    "committer ",        COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
 923 LINE(SIGNOFF,      "    Signed-off-by", COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 924 LINE(ACKED,        "    Acked-by",      COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 925 LINE(DEFAULT,      "",                  COLOR_DEFAULT,  COLOR_DEFAULT,  A_NORMAL), \
 926 LINE(CURSOR,       "",                  COLOR_WHITE,    COLOR_GREEN,    A_BOLD), \
 927 LINE(STATUS,       "",                  COLOR_GREEN,    COLOR_DEFAULT,  0), \
 928 LINE(DELIMITER,    "",                  COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
 929 LINE(DATE,         "",                  COLOR_BLUE,     COLOR_DEFAULT,  0), \
 930 LINE(MODE,         "",                  COLOR_CYAN,     COLOR_DEFAULT,  0), \
 931 LINE(LINE_NUMBER,  "",                  COLOR_CYAN,     COLOR_DEFAULT,  0), \
 932 LINE(TITLE_BLUR,   "",                  COLOR_WHITE,    COLOR_BLUE,     0), \
 933 LINE(TITLE_FOCUS,  "",                  COLOR_WHITE,    COLOR_BLUE,     A_BOLD), \
 934 LINE(MAIN_COMMIT,  "",                  COLOR_DEFAULT,  COLOR_DEFAULT,  0), \
 935 LINE(MAIN_TAG,     "",                  COLOR_MAGENTA,  COLOR_DEFAULT,  A_BOLD), \
 936 LINE(MAIN_LOCAL_TAG,"",                 COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
 937 LINE(MAIN_REMOTE,  "",                  COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 938 LINE(MAIN_TRACKED, "",                  COLOR_YELLOW,   COLOR_DEFAULT,  A_BOLD), \
 939 LINE(MAIN_REF,     "",                  COLOR_CYAN,     COLOR_DEFAULT,  0), \
 940 LINE(MAIN_HEAD,    "",                  COLOR_CYAN,     COLOR_DEFAULT,  A_BOLD), \
 941 LINE(MAIN_REVGRAPH,"",                  COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
 942 LINE(TREE_HEAD,    "",                  COLOR_DEFAULT,  COLOR_DEFAULT,  A_BOLD), \
 943 LINE(TREE_DIR,     "",                  COLOR_YELLOW,   COLOR_DEFAULT,  A_NORMAL), \
 944 LINE(TREE_FILE,    "",                  COLOR_DEFAULT,  COLOR_DEFAULT,  A_NORMAL), \
 945 LINE(STAT_HEAD,    "",                  COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 946 LINE(STAT_SECTION, "",                  COLOR_CYAN,     COLOR_DEFAULT,  0), \
 947 LINE(STAT_NONE,    "",                  COLOR_DEFAULT,  COLOR_DEFAULT,  0), \
 948 LINE(STAT_STAGED,  "",                  COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
 949 LINE(STAT_UNSTAGED,"",                  COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
 950 LINE(STAT_UNTRACKED,"",                 COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
 951 LINE(BLAME_ID,     "",                  COLOR_MAGENTA,  COLOR_DEFAULT,  0)
 952
 953 enum line_type {
 954 #define LINE(type, line, fg, bg, attr) \
 955         LINE_##type
 956         LINE_INFO,
 957         LINE_NONE
 958 #undef  LINE
 959 };
 960
 961 struct line_info {
 962         const char *name;       /* Option name. */
 963         int namelen;            /* Size of option name. */
 964         const char *line;       /* The start of line to match. */
 965         int linelen;            /* Size of string to match. */
 966         int fg, bg, attr;       /* Color and text attributes for the lines. */
 967 };
 968
 969 static struct line_info line_info[] = {
 970 #define LINE(type, line, fg, bg, attr) \
 971         { #type, STRING_SIZE(#type), (line), STRING_SIZE(line), (fg), (bg), (attr) }
 972         LINE_INFO
 973 #undef  LINE
 974 };
 975
 976 static enum line_type
 977 get_line_type(const char *line)
 978 {
 979         int linelen = strlen(line);
 980         enum line_type type;
 981
 982         for (type = 0; type < ARRAY_SIZE(line_info); type++)
 983                 /* Case insensitive search matches Signed-off-by lines better. */
 984                 if (linelen >= line_info[type].linelen &&
 985                     !strncasecmp(line_info[type].line, line, line_info[type].linelen))
 986                         return type;
 987
 988         return LINE_DEFAULT;
 989 }
 990
 991 static inline int
 992 get_line_attr(enum line_type type)
 993 {
 994         assert(type < ARRAY_SIZE(line_info));
 995         return COLOR_PAIR(type) | line_info[type].attr;
 996 }
 997
 998 static struct line_info *
 999 get_line_info(const char *name)
1000 {
1001         size_t namelen = strlen(name);
1002         enum line_type type;
1003
1004         for (type = 0; type < ARRAY_SIZE(line_info); type++)
1005                 if (namelen == line_info[type].namelen &&
1006                     !string_enum_compare(line_info[type].name, name, namelen))
1007                         return &line_info[type];
1008
1009         return NULL;
1010 }
1011
1012 static void
1013 init_colors(void)
1014 {
1015         int default_bg = line_info[LINE_DEFAULT].bg;
1016         int default_fg = line_info[LINE_DEFAULT].fg;
1017         enum line_type type;
1018
1019         start_color();
1020
1021         if (assume_default_colors(default_fg, default_bg) == ERR) {
1022                 default_bg = COLOR_BLACK;
1023                 default_fg = COLOR_WHITE;
1024         }
1025
1026         for (type = 0; type < ARRAY_SIZE(line_info); type++) {
1027                 struct line_info *info = &line_info[type];
1028                 int bg = info->bg == COLOR_DEFAULT ? default_bg : info->bg;
1029                 int fg = info->fg == COLOR_DEFAULT ? default_fg : info->fg;
1030
1031                 init_pair(type, fg, bg);
1032         }
1033 }
1034
1035 struct line {
1036         enum line_type type;
1037
1038         /* State flags */
1039         unsigned int selected:1;
1040         unsigned int dirty:1;
1041         unsigned int cleareol:1;
1042
1043         void *data;             /* User data */
1044 };
1045
1046
1047 /*
1048  * Keys
1049  */
1050
1051 struct keybinding {
1052         int alias;
1053         enum request request;
1054 };
1055
1056 static struct keybinding default_keybindings[] = {
1057         /* View switching */
1058         { 'm',          REQ_VIEW_MAIN },
1059         { 'd',          REQ_VIEW_DIFF },
1060         { 'l',          REQ_VIEW_LOG },
1061         { 't',          REQ_VIEW_TREE },
1062         { 'f',          REQ_VIEW_BLOB },
1063         { 'B',          REQ_VIEW_BLAME },
1064         { 'p',          REQ_VIEW_PAGER },
1065         { 'h',          REQ_VIEW_HELP },
1066         { 'S',          REQ_VIEW_STATUS },
1067         { 'c',          REQ_VIEW_STAGE },
1068
1069         /* View manipulation */
1070         { 'q',          REQ_VIEW_CLOSE },
1071         { KEY_TAB,      REQ_VIEW_NEXT },
1072         { KEY_RETURN,   REQ_ENTER },
1073         { KEY_UP,       REQ_PREVIOUS },
1074         { KEY_DOWN,     REQ_NEXT },
1075         { 'R',          REQ_REFRESH },
1076         { KEY_F(5),     REQ_REFRESH },
1077         { 'O',          REQ_MAXIMIZE },
1078
1079         /* Cursor navigation */
1080         { 'k',          REQ_MOVE_UP },
1081         { 'j',          REQ_MOVE_DOWN },
1082         { KEY_HOME,     REQ_MOVE_FIRST_LINE },
1083         { KEY_END,      REQ_MOVE_LAST_LINE },
1084         { KEY_NPAGE,    REQ_MOVE_PAGE_DOWN },
1085         { ' ',          REQ_MOVE_PAGE_DOWN },
1086         { KEY_PPAGE,    REQ_MOVE_PAGE_UP },
1087         { 'b',          REQ_MOVE_PAGE_UP },
1088         { '-',          REQ_MOVE_PAGE_UP },
1089
1090         /* Scrolling */
1091         { KEY_LEFT,     REQ_SCROLL_LEFT },
1092         { KEY_RIGHT,    REQ_SCROLL_RIGHT },
1093         { KEY_IC,       REQ_SCROLL_LINE_UP },
1094         { KEY_DC,       REQ_SCROLL_LINE_DOWN },
1095         { 'w',          REQ_SCROLL_PAGE_UP },
1096         { 's',          REQ_SCROLL_PAGE_DOWN },
1097
1098         /* Searching */
1099         { '/',          REQ_SEARCH },
1100         { '?',          REQ_SEARCH_BACK },
1101         { 'n',          REQ_FIND_NEXT },
1102         { 'N',          REQ_FIND_PREV },
1103
1104         /* Misc */
1105         { 'Q',          REQ_QUIT },
1106         { 'z',          REQ_STOP_LOADING },
1107         { 'v',          REQ_SHOW_VERSION },
1108         { 'r',          REQ_SCREEN_REDRAW },
1109         { '.',          REQ_TOGGLE_LINENO },
1110         { 'D',          REQ_TOGGLE_DATE },
1111         { 'A',          REQ_TOGGLE_AUTHOR },
1112         { 'g',          REQ_TOGGLE_REV_GRAPH },
1113         { 'F',          REQ_TOGGLE_REFS },
1114         { ':',          REQ_PROMPT },
1115         { 'u',          REQ_STATUS_UPDATE },
1116         { '!',          REQ_STATUS_REVERT },
1117         { 'M',          REQ_STATUS_MERGE },
1118         { '@',          REQ_STAGE_NEXT },
1119         { ',',          REQ_PARENT },
1120         { 'e',          REQ_EDIT },
1121 };
1122
1123 #define KEYMAP_INFO \
1124         KEYMAP_(GENERIC), \
1125         KEYMAP_(MAIN), \
1126         KEYMAP_(DIFF), \
1127         KEYMAP_(LOG), \
1128         KEYMAP_(TREE), \
1129         KEYMAP_(BLOB), \
1130         KEYMAP_(BLAME), \
1131         KEYMAP_(PAGER), \
1132         KEYMAP_(HELP), \
1133         KEYMAP_(STATUS), \
1134         KEYMAP_(STAGE)
1135
1136 enum keymap {
1137 #define KEYMAP_(name) KEYMAP_##name
1138         KEYMAP_INFO
1139 #undef  KEYMAP_
1140 };
1141
1142 static struct int_map keymap_table[] = {
1143 #define KEYMAP_(name) { #name, STRING_SIZE(#name), KEYMAP_##name }
1144         KEYMAP_INFO
1145 #undef  KEYMAP_
1146 };
1147
1148 #define set_keymap(map, name) \
1149         set_from_int_map(keymap_table, ARRAY_SIZE(keymap_table), map, name, strlen(name))
1150
1151 struct keybinding_table {
1152         struct keybinding *data;
1153         size_t size;
1154 };
1155
1156 static struct keybinding_table keybindings[ARRAY_SIZE(keymap_table)];
1157
1158 static void
1159 add_keybinding(enum keymap keymap, enum request request, int key)
1160 {
1161         struct keybinding_table *table = &keybindings[keymap];
1162
1163         table->data = realloc(table->data, (table->size + 1) * sizeof(*table->data));
1164         if (!table->data)
1165                 die("Failed to allocate keybinding");
1166         table->data[table->size].alias = key;
1167         table->data[table->size++].request = request;
1168 }
1169
1170 /* Looks for a key binding first in the given map, then in the generic map, and
1171  * lastly in the default keybindings. */
1172 static enum request
1173 get_keybinding(enum keymap keymap, int key)
1174 {
1175         size_t i;
1176
1177         for (i = 0; i < keybindings[keymap].size; i++)
1178                 if (keybindings[keymap].data[i].alias == key)
1179                         return keybindings[keymap].data[i].request;
1180
1181         for (i = 0; i < keybindings[KEYMAP_GENERIC].size; i++)
1182                 if (keybindings[KEYMAP_GENERIC].data[i].alias == key)
1183                         return keybindings[KEYMAP_GENERIC].data[i].request;
1184
1185         for (i = 0; i < ARRAY_SIZE(default_keybindings); i++)
1186                 if (default_keybindings[i].alias == key)
1187                         return default_keybindings[i].request;
1188
1189         return (enum request) key;
1190 }
1191
1192
1193 struct key {
1194         const char *name;
1195         int value;
1196 };
1197
1198 static struct key key_table[] = {
1199         { "Enter",      KEY_RETURN },
1200         { "Space",      ' ' },
1201         { "Backspace",  KEY_BACKSPACE },
1202         { "Tab",        KEY_TAB },
1203         { "Escape",     KEY_ESC },
1204         { "Left",       KEY_LEFT },
1205         { "Right",      KEY_RIGHT },
1206         { "Up",         KEY_UP },
1207         { "Down",       KEY_DOWN },
1208         { "Insert",     KEY_IC },
1209         { "Delete",     KEY_DC },
1210         { "Hash",       '#' },
1211         { "Home",       KEY_HOME },
1212         { "End",        KEY_END },
1213         { "PageUp",     KEY_PPAGE },
1214         { "PageDown",   KEY_NPAGE },
1215         { "F1",         KEY_F(1) },
1216         { "F2",         KEY_F(2) },
1217         { "F3",         KEY_F(3) },
1218         { "F4",         KEY_F(4) },
1219         { "F5",         KEY_F(5) },
1220         { "F6",         KEY_F(6) },
1221         { "F7",         KEY_F(7) },
1222         { "F8",         KEY_F(8) },
1223         { "F9",         KEY_F(9) },
1224         { "F10",        KEY_F(10) },
1225         { "F11",        KEY_F(11) },
1226         { "F12",        KEY_F(12) },
1227 };
1228
1229 static int
1230 get_key_value(const char *name)
1231 {
1232         int i;
1233
1234         for (i = 0; i < ARRAY_SIZE(key_table); i++)
1235                 if (!strcasecmp(key_table[i].name, name))
1236                         return key_table[i].value;
1237
1238         if (strlen(name) == 1 && isprint(*name))
1239                 return (int) *name;
1240
1241         return ERR;
1242 }
1243
1244 static const char *
1245 get_key_name(int key_value)
1246 {
1247         static char key_char[] = "'X'";
1248         const char *seq = NULL;
1249         int key;
1250
1251         for (key = 0; key < ARRAY_SIZE(key_table); key++)
1252                 if (key_table[key].value == key_value)
1253                         seq = key_table[key].name;
1254
1255         if (seq == NULL &&
1256             key_value < 127 &&
1257             isprint(key_value)) {
1258                 key_char[1] = (char) key_value;
1259                 seq = key_char;
1260         }
1261
1262         return seq ? seq : "(no key)";
1263 }
1264
1265 static const char *
1266 get_key(enum request request)
1267 {
1268         static char buf[BUFSIZ];
1269         size_t pos = 0;
1270         char *sep = "";
1271         int i;
1272
1273         buf[pos] = 0;
1274
1275         for (i = 0; i < ARRAY_SIZE(default_keybindings); i++) {
1276                 struct keybinding *keybinding = &default_keybindings[i];
1277
1278                 if (keybinding->request != request)
1279                         continue;
1280
1281                 if (!string_format_from(buf, &pos, "%s%s", sep,
1282                                         get_key_name(keybinding->alias)))
1283                         return "Too many keybindings!";
1284                 sep = ", ";
1285         }
1286
1287         return buf;
1288 }
1289
1290 struct run_request {
1291         enum keymap keymap;
1292         int key;
1293         const char *argv[SIZEOF_ARG];
1294 };
1295
1296 static struct run_request *run_request;
1297 static size_t run_requests;
1298
1299 static enum request
1300 add_run_request(enum keymap keymap, int key, int argc, const char **argv)
1301 {
1302         struct run_request *req;
1303
1304         if (argc >= ARRAY_SIZE(req->argv) - 1)
1305                 return REQ_NONE;
1306
1307         req = realloc(run_request, (run_requests + 1) * sizeof(*run_request));
1308         if (!req)
1309                 return REQ_NONE;
1310
1311         run_request = req;
1312         req = &run_request[run_requests];
1313         req->keymap = keymap;
1314         req->key = key;
1315         req->argv[0] = NULL;
1316
1317         if (!format_argv(req->argv, argv, FORMAT_NONE))
1318                 return REQ_NONE;
1319
1320         return REQ_NONE + ++run_requests;
1321 }
1322
1323 static struct run_request *
1324 get_run_request(enum request request)
1325 {
1326         if (request <= REQ_NONE)
1327                 return NULL;
1328         return &run_request[request - REQ_NONE - 1];
1329 }
1330
1331 static void
1332 add_builtin_run_requests(void)
1333 {
1334         const char *cherry_pick[] = { "git", "cherry-pick", "%(commit)", NULL };
1335         const char *gc[] = { "git", "gc", NULL };
1336         struct {
1337                 enum keymap keymap;
1338                 int key;
1339                 int argc;
1340                 const char **argv;
1341         } reqs[] = {
1342                 { KEYMAP_MAIN,    'C', ARRAY_SIZE(cherry_pick) - 1, cherry_pick },
1343                 { KEYMAP_GENERIC, 'G', ARRAY_SIZE(gc) - 1, gc },
1344         };
1345         int i;
1346
1347         for (i = 0; i < ARRAY_SIZE(reqs); i++) {
1348                 enum request req;
1349
1350                 req = add_run_request(reqs[i].keymap, reqs[i].key, reqs[i].argc, reqs[i].argv);
1351                 if (req != REQ_NONE)
1352                         add_keybinding(reqs[i].keymap, req, reqs[i].key);
1353         }
1354 }
1355
1356 /*
1357  * User config file handling.
1358  */
1359
1360 static struct int_map color_map[] = {
1361 #define COLOR_MAP(name) { #name, STRING_SIZE(#name), COLOR_##name }
1362         COLOR_MAP(DEFAULT),
1363         COLOR_MAP(BLACK),
1364         COLOR_MAP(BLUE),
1365         COLOR_MAP(CYAN),
1366         COLOR_MAP(GREEN),
1367         COLOR_MAP(MAGENTA),
1368         COLOR_MAP(RED),
1369         COLOR_MAP(WHITE),
1370         COLOR_MAP(YELLOW),
1371 };
1372
1373 #define set_color(color, name) \
1374         set_from_int_map(color_map, ARRAY_SIZE(color_map), color, name, strlen(name))
1375
1376 static struct int_map attr_map[] = {
1377 #define ATTR_MAP(name) { #name, STRING_SIZE(#name), A_##name }
1378         ATTR_MAP(NORMAL),
1379         ATTR_MAP(BLINK),
1380         ATTR_MAP(BOLD),
1381         ATTR_MAP(DIM),
1382         ATTR_MAP(REVERSE),
1383         ATTR_MAP(STANDOUT),
1384         ATTR_MAP(UNDERLINE),
1385 };
1386
1387 #define set_attribute(attr, name) \
1388         set_from_int_map(attr_map, ARRAY_SIZE(attr_map), attr, name, strlen(name))
1389
1390 static int   config_lineno;
1391 static bool  config_errors;
1392 static const char *config_msg;
1393
1394 /* Wants: object fgcolor bgcolor [attr] */
1395 static int
1396 option_color_command(int argc, const char *argv[])
1397 {
1398         struct line_info *info;
1399
1400         if (argc != 3 && argc != 4) {
1401                 config_msg = "Wrong number of arguments given to color command";
1402                 return ERR;
1403         }
1404
1405         info = get_line_info(argv[0]);
1406         if (!info) {
1407                 if (!string_enum_compare(argv[0], "main-delim", strlen("main-delim"))) {
1408                         info = get_line_info("delimiter");
1409
1410                 } else if (!string_enum_compare(argv[0], "main-date", strlen("main-date"))) {
1411                         info = get_line_info("date");
1412
1413                 } else if (!string_enum_compare(argv[0], "main-author", strlen("main-author"))) {
1414                         info = get_line_info("author");
1415
1416                 } else {
1417                         config_msg = "Unknown color name";
1418                         return ERR;
1419                 }
1420         }
1421
1422         if (set_color(&info->fg, argv[1]) == ERR ||
1423             set_color(&info->bg, argv[2]) == ERR) {
1424                 config_msg = "Unknown color";
1425                 return ERR;
1426         }
1427
1428         if (argc == 4 && set_attribute(&info->attr, argv[3]) == ERR) {
1429                 config_msg = "Unknown attribute";
1430                 return ERR;
1431         }
1432
1433         return OK;
1434 }
1435
1436 static bool parse_bool(const char *s)
1437 {
1438         return (!strcmp(s, "1") || !strcmp(s, "true") ||
1439                 !strcmp(s, "yes")) ? TRUE : FALSE;
1440 }
1441
1442 static int
1443 parse_int(const char *s, int default_value, int min, int max)
1444 {
1445         int value = atoi(s);
1446
1447         return (value < min || value > max) ? default_value : value;
1448 }
1449
1450 /* Wants: name = value */
1451 static int
1452 option_set_command(int argc, const char *argv[])
1453 {
1454         if (argc != 3) {
1455                 config_msg = "Wrong number of arguments given to set command";
1456                 return ERR;
1457         }
1458
1459         if (strcmp(argv[1], "=")) {
1460                 config_msg = "No value assigned";
1461                 return ERR;
1462         }
1463
1464         if (!strcmp(argv[0], "show-author")) {
1465                 opt_author = parse_bool(argv[2]);
1466                 return OK;
1467         }
1468
1469         if (!strcmp(argv[0], "show-date")) {
1470                 opt_date = parse_bool(argv[2]);
1471                 return OK;
1472         }
1473
1474         if (!strcmp(argv[0], "show-rev-graph")) {
1475                 opt_rev_graph = parse_bool(argv[2]);
1476                 return OK;
1477         }
1478
1479         if (!strcmp(argv[0], "show-refs")) {
1480                 opt_show_refs = parse_bool(argv[2]);
1481                 return OK;
1482         }
1483
1484         if (!strcmp(argv[0], "show-line-numbers")) {
1485                 opt_line_number = parse_bool(argv[2]);
1486                 return OK;
1487         }
1488
1489         if (!strcmp(argv[0], "line-graphics")) {
1490                 opt_line_graphics = parse_bool(argv[2]);
1491                 return OK;
1492         }
1493
1494         if (!strcmp(argv[0], "line-number-interval")) {
1495                 opt_num_interval = parse_int(argv[2], opt_num_interval, 1, 1024);
1496                 return OK;
1497         }
1498
1499         if (!strcmp(argv[0], "author-width")) {
1500                 opt_author_cols = parse_int(argv[2], opt_author_cols, 0, 1024);
1501                 return OK;
1502         }
1503
1504         if (!strcmp(argv[0], "tab-size")) {
1505                 opt_tab_size = parse_int(argv[2], opt_tab_size, 1, 1024);
1506                 return OK;
1507         }
1508
1509         if (!strcmp(argv[0], "commit-encoding")) {
1510                 const char *arg = argv[2];
1511                 int arglen = strlen(arg);
1512
1513                 switch (arg[0]) {
1514                 case '"':
1515                 case '\'':
1516                         if (arglen == 1 || arg[arglen - 1] != arg[0]) {
1517                                 config_msg = "Unmatched quotation";
1518                                 return ERR;
1519                         }
1520                         arg += 1; arglen -= 2;
1521                 default:
1522                         string_ncopy(opt_encoding, arg, strlen(arg));
1523                         return OK;
1524                 }
1525         }
1526
1527         config_msg = "Unknown variable name";
1528         return ERR;
1529 }
1530
1531 /* Wants: mode request key */
1532 static int
1533 option_bind_command(int argc, const char *argv[])
1534 {
1535         enum request request;
1536         int keymap;
1537         int key;
1538
1539         if (argc < 3) {
1540                 config_msg = "Wrong number of arguments given to bind command";
1541                 return ERR;
1542         }
1543
1544         if (set_keymap(&keymap, argv[0]) == ERR) {
1545                 config_msg = "Unknown key map";
1546                 return ERR;
1547         }
1548
1549         key = get_key_value(argv[1]);
1550         if (key == ERR) {
1551                 config_msg = "Unknown key";
1552                 return ERR;
1553         }
1554
1555         request = get_request(argv[2]);
1556         if (request == REQ_NONE) {
1557                 struct {
1558                         const char *name;
1559                         enum request request;
1560                 } obsolete[] = {
1561                         { "cherry-pick",        REQ_NONE },
1562                         { "screen-resize",      REQ_NONE },
1563                         { "tree-parent",        REQ_PARENT },
1564                 };
1565                 size_t namelen = strlen(argv[2]);
1566                 int i;
1567
1568                 for (i = 0; i < ARRAY_SIZE(obsolete); i++) {
1569                         if (namelen != strlen(obsolete[i].name) ||
1570                             string_enum_compare(obsolete[i].name, argv[2], namelen))
1571                                 continue;
1572                         if (obsolete[i].request != REQ_NONE)
1573                                 add_keybinding(keymap, obsolete[i].request, key);
1574                         config_msg = "Obsolete request name";
1575                         return ERR;
1576                 }
1577         }
1578         if (request == REQ_NONE && *argv[2]++ == '!')
1579                 request = add_run_request(keymap, key, argc - 2, argv + 2);
1580         if (request == REQ_NONE) {
1581                 config_msg = "Unknown request name";
1582                 return ERR;
1583         }
1584
1585         add_keybinding(keymap, request, key);
1586
1587         return OK;
1588 }
1589
1590 static int
1591 set_option(const char *opt, char *value)
1592 {
1593         const char *argv[SIZEOF_ARG];
1594         int argc = 0;
1595
1596         if (!argv_from_string(argv, &argc, value)) {
1597                 config_msg = "Too many option arguments";
1598                 return ERR;
1599         }
1600
1601         if (!strcmp(opt, "color"))
1602                 return option_color_command(argc, argv);
1603
1604         if (!strcmp(opt, "set"))
1605                 return option_set_command(argc, argv);
1606
1607         if (!strcmp(opt, "bind"))
1608                 return option_bind_command(argc, argv);
1609
1610         config_msg = "Unknown option command";
1611         return ERR;
1612 }
1613
1614 static int
1615 read_option(char *opt, size_t optlen, char *value, size_t valuelen)
1616 {
1617         int status = OK;
1618
1619         config_lineno++;
1620         config_msg = "Internal error";
1621
1622         /* Check for comment markers, since read_properties() will
1623          * only ensure opt and value are split at first " \t". */
1624         optlen = strcspn(opt, "#");
1625         if (optlen == 0)
1626                 return OK;
1627
1628         if (opt[optlen] != 0) {
1629                 config_msg = "No option value";
1630                 status = ERR;
1631
1632         }  else {
1633                 /* Look for comment endings in the value. */
1634                 size_t len = strcspn(value, "#");
1635
1636                 if (len < valuelen) {
1637                         valuelen = len;
1638                         value[valuelen] = 0;
1639                 }
1640
1641                 status = set_option(opt, value);
1642         }
1643
1644         if (status == ERR) {
1645                 warn("Error on line %d, near '%.*s': %s",
1646                      config_lineno, (int) optlen, opt, config_msg);
1647                 config_errors = TRUE;
1648         }
1649
1650         /* Always keep going if errors are encountered. */
1651         return OK;
1652 }
1653
1654 static void
1655 load_option_file(const char *path)
1656 {
1657         struct io io = {};
1658
1659         /* It's ok that the file doesn't exist. */
1660         if (!io_open(&io, path))
1661                 return;
1662
1663         config_lineno = 0;
1664         config_errors = FALSE;
1665
1666         if (io_load(&io, " \t", read_option) == ERR ||
1667             config_errors == TRUE)
1668                 warn("Errors while loading %s.", path);
1669 }
1670
1671 static int
1672 load_options(void)
1673 {
1674         const char *home = getenv("HOME");
1675         const char *tigrc_user = getenv("TIGRC_USER");
1676         const char *tigrc_system = getenv("TIGRC_SYSTEM");
1677         char buf[SIZEOF_STR];
1678
1679         add_builtin_run_requests();
1680
1681         if (!tigrc_system) {
1682                 if (!string_format(buf, "%s/tigrc", SYSCONFDIR))
1683                         return ERR;
1684                 tigrc_system = buf;
1685         }
1686         load_option_file(tigrc_system);
1687
1688         if (!tigrc_user) {
1689                 if (!home || !string_format(buf, "%s/.tigrc", home))
1690                         return ERR;
1691                 tigrc_user = buf;
1692         }
1693         load_option_file(tigrc_user);
1694
1695         return OK;
1696 }
1697
1698
1699 /*
1700  * The viewer
1701  */
1702
1703 struct view;
1704 struct view_ops;
1705
1706 /* The display array of active views and the index of the current view. */
1707 static struct view *display[2];
1708 static unsigned int current_view;
1709
1710 #define foreach_displayed_view(view, i) \
1711         for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
1712
1713 #define displayed_views()       (display[1] != NULL ? 2 : 1)
1714
1715 /* Current head and commit ID */
1716 static char ref_blob[SIZEOF_REF]        = "";
1717 static char ref_commit[SIZEOF_REF]      = "HEAD";
1718 static char ref_head[SIZEOF_REF]        = "HEAD";
1719
1720 struct view {
1721         const char *name;       /* View name */
1722         const char *cmd_env;    /* Command line set via environment */
1723         const char *id;         /* Points to either of ref_{head,commit,blob} */
1724
1725         struct view_ops *ops;   /* View operations */
1726
1727         enum keymap keymap;     /* What keymap does this view have */
1728         bool git_dir;           /* Whether the view requires a git directory. */
1729
1730         char ref[SIZEOF_REF];   /* Hovered commit reference */
1731         char vid[SIZEOF_REF];   /* View ID. Set to id member when updating. */
1732
1733         int height, width;      /* The width and height of the main window */
1734         WINDOW *win;            /* The main window */
1735         WINDOW *title;          /* The title window living below the main window */
1736
1737         /* Navigation */
1738         unsigned long offset;   /* Offset of the window top */
1739         unsigned long yoffset;  /* Offset from the window side. */
1740         unsigned long lineno;   /* Current line number */
1741         unsigned long p_offset; /* Previous offset of the window top */
1742         unsigned long p_yoffset;/* Previous offset from the window side */
1743         unsigned long p_lineno; /* Previous current line number */
1744         bool p_restore;         /* Should the previous position be restored. */
1745
1746         /* Searching */
1747         char grep[SIZEOF_STR];  /* Search string */
1748         regex_t *regex;         /* Pre-compiled regex */
1749
1750         /* If non-NULL, points to the view that opened this view. If this view
1751          * is closed tig will switch back to the parent view. */
1752         struct view *parent;
1753
1754         /* Buffering */
1755         size_t lines;           /* Total number of lines */
1756         struct line *line;      /* Line index */
1757         size_t line_alloc;      /* Total number of allocated lines */
1758         unsigned int digits;    /* Number of digits in the lines member. */
1759
1760         /* Drawing */
1761         struct line *curline;   /* Line currently being drawn. */
1762         enum line_type curtype; /* Attribute currently used for drawing. */
1763         unsigned long col;      /* Column when drawing. */
1764         bool has_scrolled;      /* View was scrolled. */
1765         bool can_hscroll;       /* View can be scrolled horizontally. */
1766
1767         /* Loading */
1768         struct io io;
1769         struct io *pipe;
1770         time_t start_time;
1771         time_t update_secs;
1772 };
1773
1774 struct view_ops {
1775         /* What type of content being displayed. Used in the title bar. */
1776         const char *type;
1777         /* Default command arguments. */
1778         const char **argv;
1779         /* Open and reads in all view content. */
1780         bool (*open)(struct view *view);
1781         /* Read one line; updates view->line. */
1782         bool (*read)(struct view *view, char *data);
1783         /* Draw one line; @lineno must be < view->height. */
1784         bool (*draw)(struct view *view, struct line *line, unsigned int lineno);
1785         /* Depending on view handle a special requests. */
1786         enum request (*request)(struct view *view, enum request request, struct line *line);
1787         /* Search for regex in a line. */
1788         bool (*grep)(struct view *view, struct line *line);
1789         /* Select line */
1790         void (*select)(struct view *view, struct line *line);
1791 };
1792
1793 static struct view_ops blame_ops;
1794 static struct view_ops blob_ops;
1795 static struct view_ops diff_ops;
1796 static struct view_ops help_ops;
1797 static struct view_ops log_ops;
1798 static struct view_ops main_ops;
1799 static struct view_ops pager_ops;
1800 static struct view_ops stage_ops;
1801 static struct view_ops status_ops;
1802 static struct view_ops tree_ops;
1803
1804 #define VIEW_STR(name, env, ref, ops, map, git) \
1805         { name, #env, ref, ops, map, git }
1806
1807 #define VIEW_(id, name, ops, git, ref) \
1808         VIEW_STR(name, TIG_##id##_CMD, ref, ops, KEYMAP_##id, git)
1809
1810
1811 static struct view views[] = {
1812         VIEW_(MAIN,   "main",   &main_ops,   TRUE,  ref_head),
1813         VIEW_(DIFF,   "diff",   &diff_ops,   TRUE,  ref_commit),
1814         VIEW_(LOG,    "log",    &log_ops,    TRUE,  ref_head),
1815         VIEW_(TREE,   "tree",   &tree_ops,   TRUE,  ref_commit),
1816         VIEW_(BLOB,   "blob",   &blob_ops,   TRUE,  ref_blob),
1817         VIEW_(BLAME,  "blame",  &blame_ops,  TRUE,  ref_commit),
1818         VIEW_(HELP,   "help",   &help_ops,   FALSE, ""),
1819         VIEW_(PAGER,  "pager",  &pager_ops,  FALSE, "stdin"),
1820         VIEW_(STATUS, "status", &status_ops, TRUE,  ""),
1821         VIEW_(STAGE,  "stage",  &stage_ops,  TRUE,  ""),
1822 };
1823
1824 #define VIEW(req)       (&views[(req) - REQ_OFFSET - 1])
1825 #define VIEW_REQ(view)  ((view) - views + REQ_OFFSET + 1)
1826
1827 #define foreach_view(view, i) \
1828         for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
1829
1830 #define view_is_displayed(view) \
1831         (view == display[0] || view == display[1])
1832
1833
1834 enum line_graphic {
1835         LINE_GRAPHIC_VLINE
1836 };
1837
1838 static int line_graphics[] = {
1839         /* LINE_GRAPHIC_VLINE: */ '|'
1840 };
1841
1842 static inline void
1843 set_view_attr(struct view *view, enum line_type type)
1844 {
1845         if (!view->curline->selected && view->curtype != type) {
1846                 wattrset(view->win, get_line_attr(type));
1847                 wchgat(view->win, -1, 0, type, NULL);
1848                 view->curtype = type;
1849         }
1850 }
1851
1852 static int
1853 draw_chars(struct view *view, enum line_type type, const char *string,
1854            int max_len, bool use_tilde)
1855 {
1856         int len = 0;
1857         int col = 0;
1858         int trimmed = FALSE;
1859         size_t skip = view->yoffset > view->col ? view->yoffset - view->col : 0;
1860
1861         if (max_len <= 0)
1862                 return 0;
1863
1864         if (opt_utf8) {
1865                 len = utf8_length(&string, skip, &col, max_len, &trimmed, use_tilde);
1866         } else {
1867                 col = len = strlen(string);
1868                 if (len > max_len) {
1869                         if (use_tilde) {
1870                                 max_len -= 1;
1871                         }
1872                         col = len = max_len;
1873                         trimmed = TRUE;
1874                 }
1875         }
1876
1877         set_view_attr(view, type);
1878         if (len > 0)
1879                 waddnstr(view->win, string, len);
1880         if (trimmed && use_tilde) {
1881                 set_view_attr(view, LINE_DELIMITER);
1882                 waddch(view->win, '~');
1883                 col++;
1884         }
1885
1886         if (view->col + col >= view->width + view->yoffset)
1887                 view->can_hscroll = TRUE;
1888
1889         return col;
1890 }
1891
1892 static int
1893 draw_space(struct view *view, enum line_type type, int max, int spaces)
1894 {
1895         static char space[] = "                    ";
1896         int col = 0;
1897
1898         spaces = MIN(max, spaces);
1899
1900         while (spaces > 0) {
1901                 int len = MIN(spaces, sizeof(space) - 1);
1902
1903                 col += draw_chars(view, type, space, spaces, FALSE);
1904                 spaces -= len;
1905         }
1906
1907         return col;
1908 }
1909
1910 static bool
1911 draw_lineno(struct view *view, unsigned int lineno)
1912 {
1913         size_t skip = view->yoffset > view->col ? view->yoffset - view->col : 0;
1914         char number[10];
1915         int digits3 = view->digits < 3 ? 3 : view->digits;
1916         int max_number = MIN(digits3, STRING_SIZE(number));
1917         int max = view->width - view->col;
1918         int col;
1919
1920         if (max < max_number)
1921                 max_number = max;
1922
1923         lineno += view->offset + 1;
1924         if (lineno == 1 || (lineno % opt_num_interval) == 0) {
1925                 static char fmt[] = "%1ld";
1926
1927                 if (view->digits <= 9)
1928                         fmt[1] = '0' + digits3;
1929
1930                 if (!string_format(number, fmt, lineno))
1931                         number[0] = 0;
1932                 col = draw_chars(view, LINE_LINE_NUMBER, number, max_number, TRUE);
1933         } else {
1934                 col = draw_space(view, LINE_LINE_NUMBER, max_number, max_number);
1935         }
1936
1937         if (col < max && skip <= col) {
1938                 set_view_attr(view, LINE_DEFAULT);
1939                 waddch(view->win, line_graphics[LINE_GRAPHIC_VLINE]);
1940         }
1941         col++;
1942
1943         view->col += col;
1944         if (col < max && skip <= col)
1945                 col = draw_space(view, LINE_DEFAULT, max - col, 1);
1946         view->col++;
1947
1948         return view->width + view->yoffset <= view->col;
1949 }
1950
1951 static bool
1952 draw_text(struct view *view, enum line_type type, const char *string, bool trim)
1953 {
1954         view->col += draw_chars(view, type, string, view->width + view->yoffset - view->col, trim);
1955         return view->width - view->col <= 0;
1956 }
1957
1958 static bool
1959 draw_graphic(struct view *view, enum line_type type, chtype graphic[], size_t size)
1960 {
1961         size_t skip = view->yoffset > view->col ? view->yoffset - view->col : 0;
1962         int max = view->width - view->col;
1963         int i;
1964
1965         if (max < size)
1966                 size = max;
1967
1968         set_view_attr(view, type);
1969         /* Using waddch() instead of waddnstr() ensures that
1970          * they'll be rendered correctly for the cursor line. */
1971         for (i = skip; i < size; i++)
1972                 waddch(view->win, graphic[i]);
1973
1974         view->col += size;
1975         if (size < max && skip <= size)
1976                 waddch(view->win, ' ');
1977         view->col++;
1978
1979         return view->width - view->col <= 0;
1980 }
1981
1982 static bool
1983 draw_field(struct view *view, enum line_type type, const char *text, int len, bool trim)
1984 {
1985         int max = MIN(view->width - view->col, len);
1986         int col;
1987
1988         if (text)
1989                 col = draw_chars(view, type, text, max - 1, trim);
1990         else
1991                 col = draw_space(view, type, max - 1, max - 1);
1992
1993         view->col += col;
1994         view->col += draw_space(view, LINE_DEFAULT, max - col, max - col);
1995         return view->width + view->yoffset <= view->col;
1996 }
1997
1998 static bool
1999 draw_date(struct view *view, struct tm *time)
2000 {
2001         char buf[DATE_COLS];
2002         char *date;
2003         int timelen = 0;
2004
2005         if (time)
2006                 timelen = strftime(buf, sizeof(buf), DATE_FORMAT, time);
2007         date = timelen ? buf : NULL;
2008
2009         return draw_field(view, LINE_DATE, date, DATE_COLS, FALSE);
2010 }
2011
2012 static bool
2013 draw_author(struct view *view, const char *author)
2014 {
2015         bool trim = opt_author_cols == 0 || opt_author_cols > 5 || !author;
2016
2017         if (!trim) {
2018                 static char initials[10];
2019                 size_t pos;
2020
2021 #define is_initial_sep(c) (isspace(c) || ispunct(c) || (c) == '@')
2022
2023                 memset(initials, 0, sizeof(initials));
2024                 for (pos = 0; *author && pos < opt_author_cols - 1; author++, pos++) {
2025                         while (is_initial_sep(*author))
2026                                 author++;
2027                         strncpy(&initials[pos], author, sizeof(initials) - 1 - pos);
2028                         while (*author && !is_initial_sep(author[1]))
2029                                 author++;
2030                 }
2031
2032                 author = initials;
2033         }
2034
2035         return draw_field(view, LINE_AUTHOR, author, opt_author_cols, trim);
2036 }
2037
2038 static bool
2039 draw_mode(struct view *view, mode_t mode)
2040 {
2041         static const char dir_mode[]    = "drwxr-xr-x";
2042         static const char link_mode[]   = "lrwxrwxrwx";
2043         static const char exe_mode[]    = "-rwxr-xr-x";
2044         static const char file_mode[]   = "-rw-r--r--";
2045         const char *str;
2046
2047         if (S_ISDIR(mode))
2048                 str = dir_mode;
2049         else if (S_ISLNK(mode))
2050                 str = link_mode;
2051         else if (mode & S_IXUSR)
2052                 str = exe_mode;
2053         else
2054                 str = file_mode;
2055
2056         return draw_field(view, LINE_MODE, str, sizeof(file_mode), FALSE);
2057 }
2058
2059 static bool
2060 draw_view_line(struct view *view, unsigned int lineno)
2061 {
2062         struct line *line;
2063         bool selected = (view->offset + lineno == view->lineno);
2064
2065         assert(view_is_displayed(view));
2066
2067         if (view->offset + lineno >= view->lines)
2068                 return FALSE;
2069
2070         line = &view->line[view->offset + lineno];
2071
2072         wmove(view->win, lineno, 0);
2073         if (line->cleareol)
2074                 wclrtoeol(view->win);
2075         view->col = 0;
2076         view->curline = line;
2077         view->curtype = LINE_NONE;
2078         line->selected = FALSE;
2079         line->dirty = line->cleareol = 0;
2080
2081         if (selected) {
2082                 set_view_attr(view, LINE_CURSOR);
2083                 line->selected = TRUE;
2084                 view->ops->select(view, line);
2085         }
2086
2087         return view->ops->draw(view, line, lineno);
2088 }
2089
2090 static void
2091 redraw_view_dirty(struct view *view)
2092 {
2093         bool dirty = FALSE;
2094         int lineno;
2095
2096         for (lineno = 0; lineno < view->height; lineno++) {
2097                 if (view->offset + lineno >= view->lines)
2098                         break;
2099                 if (!view->line[view->offset + lineno].dirty)
2100                         continue;
2101                 dirty = TRUE;
2102                 if (!draw_view_line(view, lineno))
2103                         break;
2104         }
2105
2106         if (!dirty)
2107                 return;
2108         wnoutrefresh(view->win);
2109 }
2110
2111 static void
2112 redraw_view_from(struct view *view, int lineno)
2113 {
2114         assert(0 <= lineno && lineno < view->height);
2115
2116         if (lineno == 0)
2117                 view->can_hscroll = FALSE;
2118
2119         for (; lineno < view->height; lineno++) {
2120                 if (!draw_view_line(view, lineno))
2121                         break;
2122         }
2123
2124         wnoutrefresh(view->win);
2125 }
2126
2127 static void
2128 redraw_view(struct view *view)
2129 {
2130         werase(view->win);
2131         redraw_view_from(view, 0);
2132 }
2133
2134
2135 static void
2136 update_view_title(struct view *view)
2137 {
2138         char buf[SIZEOF_STR];
2139         char state[SIZEOF_STR];
2140         size_t bufpos = 0, statelen = 0;
2141
2142         assert(view_is_displayed(view));
2143
2144         if (view != VIEW(REQ_VIEW_STATUS) && view->lines) {
2145                 unsigned int view_lines = view->offset + view->height;
2146                 unsigned int lines = view->lines
2147                                    ? MIN(view_lines, view->lines) * 100 / view->lines
2148                                    : 0;
2149
2150                 string_format_from(state, &statelen, " - %s %d of %d (%d%%)",
2151                                    view->ops->type,
2152                                    view->lineno + 1,
2153                                    view->lines,
2154                                    lines);
2155
2156         }
2157
2158         if (view->pipe) {
2159                 time_t secs = time(NULL) - view->start_time;
2160
2161                 /* Three git seconds are a long time ... */
2162                 if (secs > 2)
2163                         string_format_from(state, &statelen, " loading %lds", secs);
2164         }
2165
2166         string_format_from(buf, &bufpos, "[%s]", view->name);
2167         if (*view->ref && bufpos < view->width) {
2168                 size_t refsize = strlen(view->ref);
2169                 size_t minsize = bufpos + 1 + /* abbrev= */ 7 + 1 + statelen;
2170
2171                 if (minsize < view->width)
2172                         refsize = view->width - minsize + 7;
2173                 string_format_from(buf, &bufpos, " %.*s", (int) refsize, view->ref);
2174         }
2175
2176         if (statelen && bufpos < view->width) {
2177                 string_format_from(buf, &bufpos, "%s", state);
2178         }
2179
2180         if (view == display[current_view])
2181                 wbkgdset(view->title, get_line_attr(LINE_TITLE_FOCUS));
2182         else
2183                 wbkgdset(view->title, get_line_attr(LINE_TITLE_BLUR));
2184
2185         mvwaddnstr(view->title, 0, 0, buf, bufpos);
2186         wclrtoeol(view->title);
2187         wnoutrefresh(view->title);
2188 }
2189
2190 static void
2191 resize_display(void)
2192 {
2193         int offset, i;
2194         struct view *base = display[0];
2195         struct view *view = display[1] ? display[1] : display[0];
2196
2197         /* Setup window dimensions */
2198
2199         getmaxyx(stdscr, base->height, base->width);
2200
2201         /* Make room for the status window. */
2202         base->height -= 1;
2203
2204         if (view != base) {
2205                 /* Horizontal split. */
2206                 view->width   = base->width;
2207                 view->height  = SCALE_SPLIT_VIEW(base->height);
2208                 base->height -= view->height;
2209
2210                 /* Make room for the title bar. */
2211                 view->height -= 1;
2212         }
2213
2214         /* Make room for the title bar. */
2215         base->height -= 1;
2216
2217         offset = 0;
2218
2219         foreach_displayed_view (view, i) {
2220                 if (!view->win) {
2221                         view->win = newwin(view->height, 0, offset, 0);
2222                         if (!view->win)
2223                                 die("Failed to create %s view", view->name);
2224
2225                         scrollok(view->win, FALSE);
2226
2227                         view->title = newwin(1, 0, offset + view->height, 0);
2228                         if (!view->title)
2229                                 die("Failed to create title window");
2230
2231                 } else {
2232                         wresize(view->win, view->height, view->width);
2233                         mvwin(view->win,   offset, 0);
2234                         mvwin(view->title, offset + view->height, 0);
2235                 }
2236
2237                 offset += view->height + 1;
2238         }
2239 }
2240
2241 static void
2242 redraw_display(bool clear)
2243 {
2244         struct view *view;
2245         int i;
2246
2247         foreach_displayed_view (view, i) {
2248                 if (clear)
2249                         wclear(view->win);
2250                 redraw_view(view);
2251                 update_view_title(view);
2252         }
2253 }
2254
2255 static void
2256 toggle_view_option(bool *option, const char *help)
2257 {
2258         *option = !*option;
2259         redraw_display(FALSE);
2260         report("%sabling %s", *option ? "En" : "Dis", help);
2261 }
2262
2263 /*
2264  * Navigation
2265  */
2266
2267 /* Scrolling backend */
2268 static void
2269 do_scroll_view(struct view *view, int lines)
2270 {
2271         bool redraw_current_line = FALSE;
2272
2273         /* The rendering expects the new offset. */
2274         view->offset += lines;
2275
2276         assert(0 <= view->offset && view->offset < view->lines);
2277         assert(lines);
2278
2279         /* Move current line into the view. */
2280         if (view->lineno < view->offset) {
2281                 view->lineno = view->offset;
2282                 redraw_current_line = TRUE;
2283         } else if (view->lineno >= view->offset + view->height) {
2284                 view->lineno = view->offset + view->height - 1;
2285                 redraw_current_line = TRUE;
2286         }
2287
2288         assert(view->offset <= view->lineno && view->lineno < view->lines);
2289
2290         /* Redraw the whole screen if scrolling is pointless. */
2291         if (view->height < ABS(lines)) {
2292                 redraw_view(view);
2293
2294         } else {
2295                 int line = lines > 0 ? view->height - lines : 0;
2296                 int end = line + ABS(lines);
2297
2298                 scrollok(view->win, TRUE);
2299                 wscrl(view->win, lines);
2300                 scrollok(view->win, FALSE);
2301
2302                 while (line < end && draw_view_line(view, line))
2303                         line++;
2304
2305                 if (redraw_current_line)
2306                         draw_view_line(view, view->lineno - view->offset);
2307                 wnoutrefresh(view->win);
2308         }
2309
2310         view->has_scrolled = TRUE;
2311         report("");
2312 }
2313
2314 /* Scroll frontend */
2315 static void
2316 scroll_view(struct view *view, enum request request)
2317 {
2318         int lines = 1;
2319
2320         assert(view_is_displayed(view));
2321
2322         switch (request) {
2323         case REQ_SCROLL_LEFT:
2324                 if (view->yoffset == 0) {
2325                         report("Cannot scroll beyond the first column");
2326                         return;
2327                 }
2328                 if (view->yoffset <= SCROLL_INTERVAL)
2329                         view->yoffset = 0;
2330                 else
2331                         view->yoffset -= SCROLL_INTERVAL;
2332                 redraw_view_from(view, 0);
2333                 report("");
2334                 return;
2335         case REQ_SCROLL_RIGHT:
2336                 if (!view->can_hscroll) {
2337                         report("Cannot scroll beyond the last column");
2338                         return;
2339                 }
2340                 view->yoffset += SCROLL_INTERVAL;
2341                 redraw_view(view);
2342                 report("");
2343                 return;
2344         case REQ_SCROLL_PAGE_DOWN:
2345                 lines = view->height;
2346         case REQ_SCROLL_LINE_DOWN:
2347                 if (view->offset + lines > view->lines)
2348                         lines = view->lines - view->offset;
2349
2350                 if (lines == 0 || view->offset + view->height >= view->lines) {
2351                         report("Cannot scroll beyond the last line");
2352                         return;
2353                 }
2354                 break;
2355
2356         case REQ_SCROLL_PAGE_UP:
2357                 lines = view->height;
2358         case REQ_SCROLL_LINE_UP:
2359                 if (lines > view->offset)
2360                         lines = view->offset;
2361
2362                 if (lines == 0) {
2363                         report("Cannot scroll beyond the first line");
2364                         return;
2365                 }
2366
2367                 lines = -lines;
2368                 break;
2369
2370         default:
2371                 die("request %d not handled in switch", request);
2372         }
2373
2374         do_scroll_view(view, lines);
2375 }
2376
2377 /* Cursor moving */
2378 static void
2379 move_view(struct view *view, enum request request)
2380 {
2381         int scroll_steps = 0;
2382         int steps;
2383
2384         switch (request) {
2385         case REQ_MOVE_FIRST_LINE:
2386                 steps = -view->lineno;
2387                 break;
2388
2389         case REQ_MOVE_LAST_LINE:
2390                 steps = view->lines - view->lineno - 1;
2391                 break;
2392
2393         case REQ_MOVE_PAGE_UP:
2394                 steps = view->height > view->lineno
2395                       ? -view->lineno : -view->height;
2396                 break;
2397
2398         case REQ_MOVE_PAGE_DOWN:
2399                 steps = view->lineno + view->height >= view->lines
2400                       ? view->lines - view->lineno - 1 : view->height;
2401                 break;
2402
2403         case REQ_MOVE_UP:
2404                 steps = -1;
2405                 break;
2406
2407         case REQ_MOVE_DOWN:
2408                 steps = 1;
2409                 break;
2410
2411         default:
2412                 die("request %d not handled in switch", request);
2413         }
2414
2415         if (steps <= 0 && view->lineno == 0) {
2416                 report("Cannot move beyond the first line");
2417                 return;
2418
2419         } else if (steps >= 0 && view->lineno + 1 >= view->lines) {
2420                 report("Cannot move beyond the last line");
2421                 return;
2422         }
2423
2424         /* Move the current line */
2425         view->lineno += steps;
2426         assert(0 <= view->lineno && view->lineno < view->lines);
2427
2428         /* Check whether the view needs to be scrolled */
2429         if (view->lineno < view->offset ||
2430             view->lineno >= view->offset + view->height) {
2431                 scroll_steps = steps;
2432                 if (steps < 0 && -steps > view->offset) {
2433                         scroll_steps = -view->offset;
2434
2435                 } else if (steps > 0) {
2436                         if (view->lineno == view->lines - 1 &&
2437                             view->lines > view->height) {
2438                                 scroll_steps = view->lines - view->offset - 1;
2439                                 if (scroll_steps >= view->height)
2440                                         scroll_steps -= view->height - 1;
2441                         }
2442                 }
2443         }
2444
2445         if (!view_is_displayed(view)) {
2446                 view->offset += scroll_steps;
2447                 assert(0 <= view->offset && view->offset < view->lines);
2448                 view->ops->select(view, &view->line[view->lineno]);
2449                 return;
2450         }
2451
2452         /* Repaint the old "current" line if we be scrolling */
2453         if (ABS(steps) < view->height)
2454                 draw_view_line(view, view->lineno - steps - view->offset);
2455
2456         if (scroll_steps) {
2457                 do_scroll_view(view, scroll_steps);
2458                 return;
2459         }
2460
2461         /* Draw the current line */
2462         draw_view_line(view, view->lineno - view->offset);
2463
2464         wnoutrefresh(view->win);
2465         report("");
2466 }
2467
2468
2469 /*
2470  * Searching
2471  */
2472
2473 static void search_view(struct view *view, enum request request);
2474
2475 static void
2476 select_view_line(struct view *view, unsigned long lineno)
2477 {
2478         if (lineno - view->offset >= view->height) {
2479                 view->offset = lineno;
2480                 view->lineno = lineno;
2481                 if (view_is_displayed(view))
2482                         redraw_view(view);
2483
2484         } else {
2485                 unsigned long old_lineno = view->lineno - view->offset;
2486
2487                 view->lineno = lineno;
2488                 if (view_is_displayed(view)) {
2489                         draw_view_line(view, old_lineno);
2490                         draw_view_line(view, view->lineno - view->offset);
2491                         wnoutrefresh(view->win);
2492                 } else {
2493                         view->ops->select(view, &view->line[view->lineno]);
2494                 }
2495         }
2496 }
2497
2498 static void
2499 find_next(struct view *view, enum request request)
2500 {
2501         unsigned long lineno = view->lineno;
2502         int direction;
2503
2504         if (!*view->grep) {
2505                 if (!*opt_search)
2506                         report("No previous search");
2507                 else
2508                         search_view(view, request);
2509                 return;
2510         }
2511
2512         switch (request) {
2513         case REQ_SEARCH:
2514         case REQ_FIND_NEXT:
2515                 direction = 1;
2516                 break;
2517
2518         case REQ_SEARCH_BACK:
2519         case REQ_FIND_PREV:
2520                 direction = -1;
2521                 break;
2522
2523         default:
2524                 return;
2525         }
2526
2527         if (request == REQ_FIND_NEXT || request == REQ_FIND_PREV)
2528                 lineno += direction;
2529
2530         /* Note, lineno is unsigned long so will wrap around in which case it
2531          * will become bigger than view->lines. */
2532         for (; lineno < view->lines; lineno += direction) {
2533                 if (view->ops->grep(view, &view->line[lineno])) {
2534                         select_view_line(view, lineno);
2535                         report("Line %ld matches '%s'", lineno + 1, view->grep);
2536                         return;
2537                 }
2538         }
2539
2540         report("No match found for '%s'", view->grep);
2541 }
2542
2543 static void
2544 search_view(struct view *view, enum request request)
2545 {
2546         int regex_err;
2547
2548         if (view->regex) {
2549                 regfree(view->regex);
2550                 *view->grep = 0;
2551         } else {
2552                 view->regex = calloc(1, sizeof(*view->regex));
2553                 if (!view->regex)
2554                         return;
2555         }
2556
2557         regex_err = regcomp(view->regex, opt_search, REG_EXTENDED);
2558         if (regex_err != 0) {
2559                 char buf[SIZEOF_STR] = "unknown error";
2560
2561                 regerror(regex_err, view->regex, buf, sizeof(buf));
2562                 report("Search failed: %s", buf);
2563                 return;
2564         }
2565
2566         string_copy(view->grep, opt_search);
2567
2568         find_next(view, request);
2569 }
2570
2571 /*
2572  * Incremental updating
2573  */
2574
2575 static void
2576 reset_view(struct view *view)
2577 {
2578         int i;
2579
2580         for (i = 0; i < view->lines; i++)
2581                 free(view->line[i].data);
2582         free(view->line);
2583
2584         view->p_offset = view->offset;
2585         view->p_yoffset = view->yoffset;
2586         view->p_lineno = view->lineno;
2587
2588         view->line = NULL;
2589         view->offset = 0;
2590         view->yoffset = 0;
2591         view->lines  = 0;
2592         view->lineno = 0;
2593         view->line_alloc = 0;
2594         view->vid[0] = 0;
2595         view->update_secs = 0;
2596 }
2597
2598 static void
2599 free_argv(const char *argv[])
2600 {
2601         int argc;
2602
2603         for (argc = 0; argv[argc]; argc++)
2604                 free((void *) argv[argc]);
2605 }
2606
2607 static bool
2608 format_argv(const char *dst_argv[], const char *src_argv[], enum format_flags flags)
2609 {
2610         char buf[SIZEOF_STR];
2611         int argc;
2612         bool noreplace = flags == FORMAT_NONE;
2613
2614         free_argv(dst_argv);
2615
2616         for (argc = 0; src_argv[argc]; argc++) {
2617                 const char *arg = src_argv[argc];
2618                 size_t bufpos = 0;
2619
2620                 while (arg) {
2621                         char *next = strstr(arg, "%(");
2622                         int len = next - arg;
2623                         const char *value;
2624
2625                         if (!next || noreplace) {
2626                                 if (flags == FORMAT_DASH && !strcmp(arg, "--"))
2627                                         noreplace = TRUE;
2628                                 len = strlen(arg);
2629                                 value = "";
2630
2631                         } else if (!prefixcmp(next, "%(directory)")) {
2632                                 value = opt_path;
2633
2634                         } else if (!prefixcmp(next, "%(file)")) {
2635                                 value = opt_file;
2636
2637                         } else if (!prefixcmp(next, "%(ref)")) {
2638                                 value = *opt_ref ? opt_ref : "HEAD";
2639
2640                         } else if (!prefixcmp(next, "%(head)")) {
2641                                 value = ref_head;
2642
2643                         } else if (!prefixcmp(next, "%(commit)")) {
2644                                 value = ref_commit;
2645
2646                         } else if (!prefixcmp(next, "%(blob)")) {
2647                                 value = ref_blob;
2648
2649                         } else {
2650                                 report("Unknown replacement: `%s`", next);
2651                                 return FALSE;
2652                         }
2653
2654                         if (!string_format_from(buf, &bufpos, "%.*s%s", len, arg, value))
2655                                 return FALSE;
2656
2657                         arg = next && !noreplace ? strchr(next, ')') + 1 : NULL;
2658                 }
2659
2660                 dst_argv[argc] = strdup(buf);
2661                 if (!dst_argv[argc])
2662                         break;
2663         }
2664
2665         dst_argv[argc] = NULL;
2666
2667         return src_argv[argc] == NULL;
2668 }
2669
2670 static bool
2671 restore_view_position(struct view *view)
2672 {
2673         if (!view->p_restore || (view->pipe && view->lines <= view->p_lineno))
2674                 return FALSE;
2675
2676         /* Changing the view position cancels the restoring. */
2677         /* FIXME: Changing back to the first line is not detected. */
2678         if (view->offset != 0 || view->lineno != 0) {
2679                 view->p_restore = FALSE;
2680                 return FALSE;
2681         }
2682
2683         if (view->p_lineno >= view->lines) {
2684                 view->p_lineno = view->lines > 0 ? view->lines - 1 : 0;
2685                 if (view->p_offset >= view->p_lineno) {
2686                         unsigned long half = view->height / 2;
2687
2688                         if (view->p_lineno > half)
2689                                 view->p_offset = view->p_lineno - half;
2690                         else
2691                                 view->p_offset = 0;
2692                 }
2693         }
2694
2695         if (view_is_displayed(view) &&
2696             view->offset != view->p_offset &&
2697             view->lineno != view->p_lineno)
2698                 werase(view->win);
2699
2700         view->offset = view->p_offset;
2701         view->yoffset = view->p_yoffset;
2702         view->lineno = view->p_lineno;
2703         view->p_restore = FALSE;
2704
2705         return TRUE;
2706 }
2707
2708 static void
2709 end_update(struct view *view, bool force)
2710 {
2711         if (!view->pipe)
2712                 return;
2713         while (!view->ops->read(view, NULL))
2714                 if (!force)
2715                         return;
2716         set_nonblocking_input(FALSE);
2717         if (force)
2718                 kill_io(view->pipe);
2719         done_io(view->pipe);
2720         view->pipe = NULL;
2721 }
2722
2723 static void
2724 setup_update(struct view *view, const char *vid)
2725 {
2726         set_nonblocking_input(TRUE);
2727         reset_view(view);
2728         string_copy_rev(view->vid, vid);
2729         view->pipe = &view->io;
2730         view->start_time = time(NULL);
2731 }
2732
2733 static bool
2734 prepare_update(struct view *view, const char *argv[], const char *dir,
2735                enum format_flags flags)
2736 {
2737         if (view->pipe)
2738                 end_update(view, TRUE);
2739         return init_io_rd(&view->io, argv, dir, flags);
2740 }
2741
2742 static bool
2743 prepare_update_file(struct view *view, const char *name)
2744 {
2745         if (view->pipe)
2746                 end_update(view, TRUE);
2747         return io_open(&view->io, name);
2748 }
2749
2750 static bool
2751 begin_update(struct view *view, bool refresh)
2752 {
2753         if (view->pipe)
2754                 end_update(view, TRUE);
2755
2756         if (refresh) {
2757                 if (!start_io(&view->io))
2758                         return FALSE;
2759
2760         } else {
2761                 if (view == VIEW(REQ_VIEW_TREE) && strcmp(view->vid, view->id))
2762                         opt_path[0] = 0;
2763
2764                 if (!run_io_rd(&view->io, view->ops->argv, FORMAT_ALL))
2765                         return FALSE;
2766
2767                 /* Put the current ref_* value to the view title ref
2768                  * member. This is needed by the blob view. Most other
2769                  * views sets it automatically after loading because the
2770                  * first line is a commit line. */
2771                 string_copy_rev(view->ref, view->id);
2772         }
2773
2774         setup_update(view, view->id);
2775
2776         return TRUE;
2777 }
2778
2779 #define ITEM_CHUNK_SIZE 256
2780 static void *
2781 realloc_items(void *mem, size_t *size, size_t new_size, size_t item_size)
2782 {
2783         size_t num_chunks = *size / ITEM_CHUNK_SIZE;
2784         size_t num_chunks_new = (new_size + ITEM_CHUNK_SIZE - 1) / ITEM_CHUNK_SIZE;
2785
2786         if (mem == NULL || num_chunks != num_chunks_new) {
2787                 *size = num_chunks_new * ITEM_CHUNK_SIZE;
2788                 mem = realloc(mem, *size * item_size);
2789         }
2790
2791         return mem;
2792 }
2793
2794 static struct line *
2795 realloc_lines(struct view *view, size_t line_size)
2796 {
2797         size_t alloc = view->line_alloc;
2798         struct line *tmp = realloc_items(view->line, &alloc, line_size,
2799                                          sizeof(*view->line));
2800
2801         if (!tmp)
2802                 return NULL;
2803
2804         view->line = tmp;
2805         view->line_alloc = alloc;
2806         return view->line;
2807 }
2808
2809 static bool
2810 update_view(struct view *view)
2811 {
2812         char out_buffer[BUFSIZ * 2];
2813         char *line;
2814         /* Clear the view and redraw everything since the tree sorting
2815          * might have rearranged things. */
2816         bool redraw = view->lines == 0;
2817         bool can_read = TRUE;
2818
2819         if (!view->pipe)
2820                 return TRUE;
2821
2822         if (!io_can_read(view->pipe)) {
2823                 if (view->lines == 0) {
2824                         time_t secs = time(NULL) - view->start_time;
2825
2826                         if (secs > 1 && secs > view->update_secs) {
2827                                 if (view->update_secs == 0)
2828                                         redraw_view(view);
2829                                 update_view_title(view);
2830                                 view->update_secs = secs;
2831                         }
2832                 }
2833                 return TRUE;
2834         }
2835
2836         for (; (line = io_get(view->pipe, '\n', can_read)); can_read = FALSE) {
2837                 if (opt_iconv != ICONV_NONE) {
2838                         ICONV_CONST char *inbuf = line;
2839                         size_t inlen = strlen(line) + 1;
2840
2841                         char *outbuf = out_buffer;
2842                         size_t outlen = sizeof(out_buffer);
2843
2844                         size_t ret;
2845
2846                         ret = iconv(opt_iconv, &inbuf, &inlen, &outbuf, &outlen);
2847                         if (ret != (size_t) -1)
2848                                 line = out_buffer;
2849                 }
2850
2851                 if (!view->ops->read(view, line)) {
2852                         report("Allocation failure");
2853                         end_update(view, TRUE);
2854                         return FALSE;
2855                 }
2856         }
2857
2858         {
2859                 unsigned long lines = view->lines;
2860                 int digits;
2861
2862                 for (digits = 0; lines; digits++)
2863                         lines /= 10;
2864
2865                 /* Keep the displayed view in sync with line number scaling. */
2866                 if (digits != view->digits) {
2867                         view->digits = digits;
2868                         if (opt_line_number || view == VIEW(REQ_VIEW_BLAME))
2869                                 redraw = TRUE;
2870                 }
2871         }
2872
2873         if (io_error(view->pipe)) {
2874                 report("Failed to read: %s", io_strerror(view->pipe));
2875                 end_update(view, TRUE);
2876
2877         } else if (io_eof(view->pipe)) {
2878                 report("");
2879                 end_update(view, FALSE);
2880         }
2881
2882         if (restore_view_position(view))
2883                 redraw = TRUE;
2884
2885         if (!view_is_displayed(view))
2886                 return TRUE;
2887
2888         if (redraw)
2889                 redraw_view_from(view, 0);
2890         else
2891                 redraw_view_dirty(view);
2892
2893         /* Update the title _after_ the redraw so that if the redraw picks up a
2894          * commit reference in view->ref it'll be available here. */
2895         update_view_title(view);
2896         return TRUE;
2897 }
2898
2899 static struct line *
2900 add_line_data(struct view *view, void *data, enum line_type type)
2901 {
2902         struct line *line;
2903
2904         if (!realloc_lines(view, view->lines + 1))
2905                 return NULL;
2906
2907         line = &view->line[view->lines++];
2908         memset(line, 0, sizeof(*line));
2909         line->type = type;
2910         line->data = data;
2911         line->dirty = 1;
2912
2913         return line;
2914 }
2915
2916 static struct line *
2917 add_line_text(struct view *view, const char *text, enum line_type type)
2918 {
2919         char *data = text ? strdup(text) : NULL;
2920
2921         return data ? add_line_data(view, data, type) : NULL;
2922 }
2923
2924 static struct line *
2925 add_line_format(struct view *view, enum line_type type, const char *fmt, ...)
2926 {
2927         char buf[SIZEOF_STR];
2928         va_list args;
2929
2930         va_start(args, fmt);
2931         if (vsnprintf(buf, sizeof(buf), fmt, args) >= sizeof(buf))
2932                 buf[0] = 0;
2933         va_end(args);
2934
2935         return buf[0] ? add_line_text(view, buf, type) : NULL;
2936 }
2937
2938 /*
2939  * View opening
2940  */
2941
2942 enum open_flags {
2943         OPEN_DEFAULT = 0,       /* Use default view switching. */
2944         OPEN_SPLIT = 1,         /* Split current view. */
2945         OPEN_BACKGROUNDED = 2,  /* Backgrounded. */
2946         OPEN_RELOAD = 4,        /* Reload view even if it is the current. */
2947         OPEN_NOMAXIMIZE = 8,    /* Do not maximize the current view. */
2948         OPEN_REFRESH = 16,      /* Refresh view using previous command. */
2949         OPEN_PREPARED = 32,     /* Open already prepared command. */
2950 };
2951
2952 static void
2953 open_view(struct view *prev, enum request request, enum open_flags flags)
2954 {
2955         bool backgrounded = !!(flags & OPEN_BACKGROUNDED);
2956         bool split = !!(flags & OPEN_SPLIT);
2957         bool reload = !!(flags & (OPEN_RELOAD | OPEN_REFRESH | OPEN_PREPARED));
2958         bool nomaximize = !!(flags & (OPEN_NOMAXIMIZE | OPEN_REFRESH));
2959         struct view *view = VIEW(request);
2960         int nviews = displayed_views();
2961         struct view *base_view = display[0];
2962
2963         if (view == prev && nviews == 1 && !reload) {
2964                 report("Already in %s view", view->name);
2965                 return;
2966         }
2967
2968         if (view->git_dir && !opt_git_dir[0]) {
2969                 report("The %s view is disabled in pager view", view->name);
2970                 return;
2971         }
2972
2973         if (split) {
2974                 display[1] = view;
2975                 if (!backgrounded)
2976                         current_view = 1;
2977         } else if (!nomaximize) {
2978                 /* Maximize the current view. */
2979                 memset(display, 0, sizeof(display));
2980                 current_view = 0;
2981                 display[current_view] = view;
2982         }
2983
2984         /* Resize the view when switching between split- and full-screen,
2985          * or when switching between two different full-screen views. */
2986         if (nviews != displayed_views() ||
2987             (nviews == 1 && base_view != display[0]))
2988                 resize_display();
2989
2990         if (view->ops->open) {
2991                 if (view->pipe)
2992                         end_update(view, TRUE);
2993                 if (!view->ops->open(view)) {
2994                         report("Failed to load %s view", view->name);
2995                         return;
2996                 }
2997                 restore_view_position(view);
2998
2999         } else if ((reload || strcmp(view->vid, view->id)) &&
3000                    !begin_update(view, flags & (OPEN_REFRESH | OPEN_PREPARED))) {
3001                 report("Failed to load %s view", view->name);
3002                 return;
3003         }
3004
3005         if (split && prev->lineno - prev->offset >= prev->height) {
3006                 /* Take the title line into account. */
3007                 int lines = prev->lineno - prev->offset - prev->height + 1;
3008
3009                 /* Scroll the view that was split if the current line is
3010                  * outside the new limited view. */
3011                 do_scroll_view(prev, lines);
3012         }
3013
3014         if (prev && view != prev) {
3015                 if (split && !backgrounded) {
3016                         /* "Blur" the previous view. */
3017                         update_view_title(prev);
3018                 }
3019
3020                 view->parent = prev;
3021         }
3022
3023         if (view->pipe && view->lines == 0) {
3024                 /* Clear the old view and let the incremental updating refill
3025                  * the screen. */
3026                 werase(view->win);
3027                 view->p_restore = flags & (OPEN_RELOAD | OPEN_REFRESH);
3028                 report("");
3029         } else if (view_is_displayed(view)) {
3030                 redraw_view(view);
3031                 report("");
3032         }
3033
3034         /* If the view is backgrounded the above calls to report()
3035          * won't redraw the view title. */
3036         if (backgrounded)
3037                 update_view_title(view);
3038 }
3039
3040 static void
3041 open_external_viewer(const char *argv[], const char *dir)
3042 {
3043         def_prog_mode();           /* save current tty modes */
3044         endwin();                  /* restore original tty modes */
3045         run_io_fg(argv, dir);
3046         fprintf(stderr, "Press Enter to continue");
3047         getc(opt_tty);
3048         reset_prog_mode();
3049         redraw_display(TRUE);
3050 }
3051
3052 static void
3053 open_mergetool(const char *file)
3054 {
3055         const char *mergetool_argv[] = { "git", "mergetool", file, NULL };
3056
3057         open_external_viewer(mergetool_argv, opt_cdup);
3058 }
3059
3060 static void
3061 open_editor(bool from_root, const char *file)
3062 {
3063         const char *editor_argv[] = { "vi", file, NULL };
3064         const char *editor;
3065
3066         editor = getenv("GIT_EDITOR");
3067         if (!editor && *opt_editor)
3068                 editor = opt_editor;
3069         if (!editor)
3070                 editor = getenv("VISUAL");
3071         if (!editor)
3072                 editor = getenv("EDITOR");
3073         if (!editor)
3074                 editor = "vi";
3075
3076         editor_argv[0] = editor;
3077         open_external_viewer(editor_argv, from_root ? opt_cdup : NULL);
3078 }
3079
3080 static void
3081 open_run_request(enum request request)
3082 {
3083         struct run_request *req = get_run_request(request);
3084         const char *argv[ARRAY_SIZE(req->argv)] = { NULL };
3085
3086         if (!req) {
3087                 report("Unknown run request");
3088                 return;
3089         }
3090
3091         if (format_argv(argv, req->argv, FORMAT_ALL))
3092                 open_external_viewer(argv, NULL);
3093         free_argv(argv);
3094 }
3095
3096 /*
3097  * User request switch noodle
3098  */
3099
3100 static int
3101 view_driver(struct view *view, enum request request)
3102 {
3103         int i;
3104
3105         if (request == REQ_NONE) {
3106                 doupdate();
3107                 return TRUE;
3108         }
3109
3110         if (request > REQ_NONE) {
3111                 open_run_request(request);
3112                 /* FIXME: When all views can refresh always do this. */
3113                 if (view == VIEW(REQ_VIEW_STATUS) ||
3114                     view == VIEW(REQ_VIEW_MAIN) ||
3115                     view == VIEW(REQ_VIEW_LOG) ||
3116                     view == VIEW(REQ_VIEW_STAGE))
3117                         request = REQ_REFRESH;
3118                 else
3119                         return TRUE;
3120         }
3121
3122         if (view && view->lines) {
3123                 request = view->ops->request(view, request, &view->line[view->lineno]);
3124                 if (request == REQ_NONE)
3125                         return TRUE;
3126         }
3127
3128         switch (request) {
3129         case REQ_MOVE_UP:
3130         case REQ_MOVE_DOWN:
3131         case REQ_MOVE_PAGE_UP:
3132         case REQ_MOVE_PAGE_DOWN:
3133         case REQ_MOVE_FIRST_LINE:
3134         case REQ_MOVE_LAST_LINE:
3135                 move_view(view, request);
3136                 break;
3137
3138         case REQ_SCROLL_LEFT:
3139         case REQ_SCROLL_RIGHT:
3140         case REQ_SCROLL_LINE_DOWN:
3141         case REQ_SCROLL_LINE_UP:
3142         case REQ_SCROLL_PAGE_DOWN:
3143         case REQ_SCROLL_PAGE_UP:
3144                 scroll_view(view, request);
3145                 break;
3146
3147         case REQ_VIEW_BLAME:
3148                 if (!opt_file[0]) {
3149                         report("No file chosen, press %s to open tree view",
3150                                get_key(REQ_VIEW_TREE));
3151                         break;
3152                 }
3153                 open_view(view, request, OPEN_DEFAULT);
3154                 break;
3155
3156         case REQ_VIEW_BLOB:
3157                 if (!ref_blob[0]) {
3158                         report("No file chosen, press %s to open tree view",
3159                                get_key(REQ_VIEW_TREE));
3160                         break;
3161                 }
3162                 open_view(view, request, OPEN_DEFAULT);
3163                 break;
3164
3165         case REQ_VIEW_PAGER:
3166                 if (!VIEW(REQ_VIEW_PAGER)->pipe && !VIEW(REQ_VIEW_PAGER)->lines) {
3167                         report("No pager content, press %s to run command from prompt",
3168                                get_key(REQ_PROMPT));
3169                         break;
3170                 }
3171                 open_view(view, request, OPEN_DEFAULT);
3172                 break;
3173
3174         case REQ_VIEW_STAGE:
3175                 if (!VIEW(REQ_VIEW_STAGE)->lines) {
3176                         report("No stage content, press %s to open the status view and choose file",
3177                                get_key(REQ_VIEW_STATUS));
3178                         break;
3179                 }
3180                 open_view(view, request, OPEN_DEFAULT);
3181                 break;
3182
3183         case REQ_VIEW_STATUS:
3184                 if (opt_is_inside_work_tree == FALSE) {
3185                         report("The status view requires a working tree");
3186                         break;
3187                 }
3188                 open_view(view, request, OPEN_DEFAULT);
3189                 break;
3190
3191         case REQ_VIEW_MAIN:
3192         case REQ_VIEW_DIFF:
3193         case REQ_VIEW_LOG:
3194         case REQ_VIEW_TREE:
3195         case REQ_VIEW_HELP:
3196                 open_view(view, request, OPEN_DEFAULT);
3197                 break;
3198
3199         case REQ_NEXT:
3200         case REQ_PREVIOUS:
3201                 request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
3202
3203                 if ((view == VIEW(REQ_VIEW_DIFF) &&
3204                      view->parent == VIEW(REQ_VIEW_MAIN)) ||
3205                    (view == VIEW(REQ_VIEW_DIFF) &&
3206                      view->parent == VIEW(REQ_VIEW_BLAME)) ||
3207                    (view == VIEW(REQ_VIEW_STAGE) &&
3208                      view->parent == VIEW(REQ_VIEW_STATUS)) ||
3209                    (view == VIEW(REQ_VIEW_BLOB) &&
3210                      view->parent == VIEW(REQ_VIEW_TREE))) {
3211                         int line;
3212
3213                         view = view->parent;
3214                         line = view->lineno;
3215                         move_view(view, request);
3216                         if (view_is_displayed(view))
3217                                 update_view_title(view);
3218                         if (line != view->lineno)
3219                                 view->ops->request(view, REQ_ENTER,
3220                                                    &view->line[view->lineno]);
3221
3222                 } else {
3223                         move_view(view, request);
3224                 }
3225                 break;
3226
3227         case REQ_VIEW_NEXT:
3228         {
3229                 int nviews = displayed_views();
3230                 int next_view = (current_view + 1) % nviews;
3231
3232                 if (next_view == current_view) {
3233                         report("Only one view is displayed");
3234                         break;
3235                 }
3236
3237                 current_view = next_view;
3238                 /* Blur out the title of the previous view. */
3239                 update_view_title(view);
3240                 report("");
3241                 break;
3242         }
3243         case REQ_REFRESH:
3244                 report("Refreshing is not yet supported for the %s view", view->name);
3245                 break;
3246
3247         case REQ_MAXIMIZE:
3248                 if (displayed_views() == 2)
3249                         open_view(view, VIEW_REQ(view), OPEN_DEFAULT);
3250                 break;
3251
3252         case REQ_TOGGLE_LINENO:
3253                 toggle_view_option(&opt_line_number, "line numbers");
3254                 break;
3255
3256         case REQ_TOGGLE_DATE:
3257                 toggle_view_option(&opt_date, "date display");
3258                 break;
3259
3260         case REQ_TOGGLE_AUTHOR:
3261                 toggle_view_option(&opt_author, "author display");
3262                 break;
3263
3264         case REQ_TOGGLE_REV_GRAPH:
3265                 toggle_view_option(&opt_rev_graph, "revision graph display");
3266                 break;
3267
3268         case REQ_TOGGLE_REFS:
3269                 toggle_view_option(&opt_show_refs, "reference display");
3270                 break;
3271
3272         case REQ_SEARCH:
3273         case REQ_SEARCH_BACK:
3274                 search_view(view, request);
3275                 break;
3276
3277         case REQ_FIND_NEXT:
3278         case REQ_FIND_PREV:
3279                 find_next(view, request);
3280                 break;
3281
3282         case REQ_STOP_LOADING:
3283                 for (i = 0; i < ARRAY_SIZE(views); i++) {
3284                         view = &views[i];
3285                         if (view->pipe)
3286                                 report("Stopped loading the %s view", view->name),
3287                         end_update(view, TRUE);
3288                 }
3289                 break;
3290
3291         case REQ_SHOW_VERSION:
3292                 report("tig-%s (built %s)", TIG_VERSION, __DATE__);
3293                 return TRUE;
3294
3295         case REQ_SCREEN_REDRAW:
3296                 redraw_display(TRUE);
3297                 break;
3298
3299         case REQ_EDIT:
3300                 report("Nothing to edit");
3301                 break;
3302
3303         case REQ_ENTER:
3304                 report("Nothing to enter");
3305                 break;
3306
3307         case REQ_VIEW_CLOSE:
3308                 /* XXX: Mark closed views by letting view->parent point to the
3309                  * view itself. Parents to closed view should never be
3310                  * followed. */
3311                 if (view->parent &&
3312                     view->parent->parent != view->parent) {
3313                         memset(display, 0, sizeof(display));
3314                         current_view = 0;
3315                         display[current_view] = view->parent;
3316                         view->parent = view;
3317                         resize_display();
3318                         redraw_display(FALSE);
3319                         report("");
3320                         break;
3321                 }
3322                 /* Fall-through */
3323         case REQ_QUIT:
3324                 return FALSE;
3325
3326         default:
3327                 report("Unknown key, press 'h' for help");
3328                 return TRUE;
3329         }
3330
3331         return TRUE;
3332 }
3333
3334
3335 /*
3336  * View backend utilities
3337  */
3338
3339 /* Parse author lines where the name may be empty:
3340  *      author  <email@address.tld> 1138474660 +0100
3341  */
3342 static void
3343 parse_author_line(char *ident, char *author, size_t authorsize, struct tm *tm)
3344 {
3345         char *nameend = strchr(ident, '<');
3346         char *emailend = strchr(ident, '>');
3347
3348         if (nameend && emailend)
3349                 *nameend = *emailend = 0;
3350         ident = chomp_string(ident);
3351         if (!*ident) {
3352                 if (nameend)
3353                         ident = chomp_string(nameend + 1);
3354                 if (!*ident)
3355                         ident = "Unknown";
3356         }
3357
3358         string_ncopy_do(author, authorsize, ident, strlen(ident));
3359
3360         /* Parse epoch and timezone */
3361         if (emailend && emailend[1] == ' ') {
3362                 char *secs = emailend + 2;
3363                 char *zone = strchr(secs, ' ');
3364                 time_t time = (time_t) atol(secs);
3365
3366                 if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
3367                         long tz;
3368
3369                         zone++;
3370                         tz  = ('0' - zone[1]) * 60 * 60 * 10;
3371                         tz += ('0' - zone[2]) * 60 * 60;
3372                         tz += ('0' - zone[3]) * 60;
3373                         tz += ('0' - zone[4]) * 60;
3374
3375                         if (zone[0] == '-')
3376                                 tz = -tz;
3377
3378                         time -= tz;
3379                 }
3380
3381                 gmtime_r(&time, tm);
3382         }
3383 }
3384
3385 static enum input_status
3386 select_commit_parent_handler(void *data, char *buf, int c)
3387 {
3388         size_t parents = *(size_t *) data;
3389         int parent = 0;
3390
3391         if (!isdigit(c))
3392                 return INPUT_SKIP;
3393
3394         if (*buf)
3395                 parent = atoi(buf) * 10;
3396         parent += c - '0';
3397
3398         if (parent > parents)
3399                 return INPUT_SKIP;
3400         return INPUT_OK;
3401 }
3402
3403 static bool
3404 select_commit_parent(const char *id, char rev[SIZEOF_REV])
3405 {
3406         char buf[SIZEOF_STR * 4];
3407         const char *revlist_argv[] = {
3408                 "git", "rev-list", "-1", "--parents", id, NULL
3409         };
3410         int parents;
3411
3412         if (!run_io_buf(revlist_argv, buf, sizeof(buf)) ||
3413             !*chomp_string(buf) ||
3414             (parents = (strlen(buf) / 40) - 1) < 0) {
3415                 report("Failed to get parent information");
3416                 return FALSE;
3417
3418         } else if (parents == 0) {
3419                 report("The selected commit has no parents");
3420                 return FALSE;
3421         }
3422
3423         if (parents > 1) {
3424                 char prompt[SIZEOF_STR];
3425                 char *result;
3426
3427                 if (!string_format(prompt, "Which parent? [1..%d] ", parents))
3428                         return FALSE;
3429                 result = prompt_input(prompt, select_commit_parent_handler, &parents);
3430                 if (!result)
3431                         return FALSE;
3432                 parents = atoi(result);
3433         }
3434
3435         string_copy_rev(rev, &buf[41 * parents]);
3436         return TRUE;
3437 }
3438
3439 /*
3440  * Pager backend
3441  */
3442
3443 static bool
3444 pager_draw(struct view *view, struct line *line, unsigned int lineno)
3445 {
3446         char text[SIZEOF_STR];
3447
3448         if (opt_line_number && draw_lineno(view, lineno))
3449                 return TRUE;
3450
3451         string_expand(text, sizeof(text), line->data, opt_tab_size);
3452         draw_text(view, line->type, text, TRUE);
3453         return TRUE;
3454 }
3455
3456 static bool
3457 add_describe_ref(char *buf, size_t *bufpos, const char *commit_id, const char *sep)
3458 {
3459         const char *describe_argv[] = { "git", "describe", commit_id, NULL };
3460         char refbuf[SIZEOF_STR];
3461         char *ref = NULL;
3462
3463         if (run_io_buf(describe_argv, refbuf, sizeof(refbuf)))
3464                 ref = chomp_string(refbuf);
3465
3466         if (!ref || !*ref)
3467                 return TRUE;
3468
3469         /* This is the only fatal call, since it can "corrupt" the buffer. */
3470         if (!string_nformat(buf, SIZEOF_STR, bufpos, "%s%s", sep, ref))
3471                 return FALSE;
3472
3473         return TRUE;
3474 }
3475
3476 static void
3477 add_pager_refs(struct view *view, struct line *line)
3478 {
3479         char buf[SIZEOF_STR];
3480         char *commit_id = (char *)line->data + STRING_SIZE("commit ");
3481         struct ref **refs;
3482         size_t bufpos = 0, refpos = 0;
3483         const char *sep = "Refs: ";
3484         bool is_tag = FALSE;
3485
3486         assert(line->type == LINE_COMMIT);
3487
3488         refs = get_refs(commit_id);
3489         if (!refs) {
3490                 if (view == VIEW(REQ_VIEW_DIFF))
3491                         goto try_add_describe_ref;
3492                 return;
3493         }
3494
3495         do {
3496                 struct ref *ref = refs[refpos];
3497                 const char *fmt = ref->tag    ? "%s[%s]" :
3498                                   ref->remote ? "%s<%s>" : "%s%s";
3499
3500                 if (!string_format_from(buf, &bufpos, fmt, sep, ref->name))
3501                         return;
3502                 sep = ", ";
3503                 if (ref->tag)
3504                         is_tag = TRUE;
3505         } while (refs[refpos++]->next);
3506
3507         if (!is_tag && view == VIEW(REQ_VIEW_DIFF)) {
3508 try_add_describe_ref:
3509                 /* Add <tag>-g<commit_id> "fake" reference. */
3510                 if (!add_describe_ref(buf, &bufpos, commit_id, sep))
3511                         return;
3512         }
3513
3514         if (bufpos == 0)
3515                 return;
3516
3517         add_line_text(view, buf, LINE_PP_REFS);
3518 }
3519
3520 static bool
3521 pager_read(struct view *view, char *data)
3522 {
3523         struct line *line;
3524
3525         if (!data)
3526                 return TRUE;
3527
3528         line = add_line_text(view, data, get_line_type(data));
3529         if (!line)
3530                 return FALSE;
3531
3532         if (line->type == LINE_COMMIT &&
3533             (view == VIEW(REQ_VIEW_DIFF) ||
3534              view == VIEW(REQ_VIEW_LOG)))
3535                 add_pager_refs(view, line);
3536
3537         return TRUE;
3538 }
3539
3540 static enum request
3541 pager_request(struct view *view, enum request request, struct line *line)
3542 {
3543         int split = 0;
3544
3545         if (request != REQ_ENTER)
3546                 return request;
3547
3548         if (line->type == LINE_COMMIT &&
3549            (view == VIEW(REQ_VIEW_LOG) ||
3550             view == VIEW(REQ_VIEW_PAGER))) {
3551                 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
3552                 split = 1;
3553         }
3554
3555         /* Always scroll the view even if it was split. That way
3556          * you can use Enter to scroll through the log view and
3557          * split open each commit diff. */
3558         scroll_view(view, REQ_SCROLL_LINE_DOWN);
3559
3560         /* FIXME: A minor workaround. Scrolling the view will call report("")
3561          * but if we are scrolling a non-current view this won't properly
3562          * update the view title. */
3563         if (split)
3564                 update_view_title(view);
3565
3566         return REQ_NONE;
3567 }
3568
3569 static bool
3570 pager_grep(struct view *view, struct line *line)
3571 {
3572         regmatch_t pmatch;
3573         char *text = line->data;
3574
3575         if (!*text)
3576                 return FALSE;
3577
3578         if (regexec(view->regex, text, 1, &pmatch, 0) == REG_NOMATCH)
3579                 return FALSE;
3580
3581         return TRUE;
3582 }
3583
3584 static void
3585 pager_select(struct view *view, struct line *line)
3586 {
3587         if (line->type == LINE_COMMIT) {
3588                 char *text = (char *)line->data + STRING_SIZE("commit ");
3589
3590                 if (view != VIEW(REQ_VIEW_PAGER))
3591                         string_copy_rev(view->ref, text);
3592                 string_copy_rev(ref_commit, text);
3593         }
3594 }
3595
3596 static struct view_ops pager_ops = {
3597         "line",
3598         NULL,
3599         NULL,
3600         pager_read,
3601         pager_draw,
3602         pager_request,
3603         pager_grep,
3604         pager_select,
3605 };
3606
3607 static const char *log_argv[SIZEOF_ARG] = {
3608         "git", "log", "--no-color", "--cc", "--stat", "-n100", "%(head)", NULL
3609 };
3610
3611 static enum request
3612 log_request(struct view *view, enum request request, struct line *line)
3613 {
3614         switch (request) {
3615         case REQ_REFRESH:
3616                 load_refs();
3617                 open_view(view, REQ_VIEW_LOG, OPEN_REFRESH);
3618                 return REQ_NONE;
3619         default:
3620                 return pager_request(view, request, line);
3621         }
3622 }
3623
3624 static struct view_ops log_ops = {
3625         "line",
3626         log_argv,
3627         NULL,
3628         pager_read,
3629         pager_draw,
3630         log_request,
3631         pager_grep,
3632         pager_select,
3633 };
3634
3635 static const char *diff_argv[SIZEOF_ARG] = {
3636         "git", "show", "--pretty=fuller", "--no-color", "--root",
3637                 "--patch-with-stat", "--find-copies-harder", "-C", "%(commit)", NULL
3638 };
3639
3640 static struct view_ops diff_ops = {
3641         "line",
3642         diff_argv,
3643         NULL,
3644         pager_read,
3645         pager_draw,
3646         pager_request,
3647         pager_grep,
3648         pager_select,
3649 };
3650
3651 /*
3652  * Help backend
3653  */
3654
3655 static bool
3656 help_open(struct view *view)
3657 {
3658         char buf[SIZEOF_STR];
3659         size_t bufpos;
3660         int i;
3661
3662         if (view->lines > 0)
3663                 return TRUE;
3664
3665         add_line_text(view, "Quick reference for tig keybindings:", LINE_DEFAULT);
3666
3667         for (i = 0; i < ARRAY_SIZE(req_info); i++) {
3668                 const char *key;
3669
3670                 if (req_info[i].request == REQ_NONE)
3671                         continue;
3672
3673                 if (!req_info[i].request) {
3674                         add_line_text(view, "", LINE_DEFAULT);
3675                         add_line_text(view, req_info[i].help, LINE_DEFAULT);
3676                         continue;
3677                 }
3678
3679                 key = get_key(req_info[i].request);
3680                 if (!*key)
3681                         key = "(no key defined)";
3682
3683                 for (bufpos = 0; bufpos <= req_info[i].namelen; bufpos++) {
3684                         buf[bufpos] = tolower(req_info[i].name[bufpos]);
3685                         if (buf[bufpos] == '_')
3686                                 buf[bufpos] = '-';
3687                 }
3688
3689                 add_line_format(view, LINE_DEFAULT, "    %-25s %-20s %s",
3690                                 key, buf, req_info[i].help);
3691         }
3692
3693         if (run_requests) {
3694                 add_line_text(view, "", LINE_DEFAULT);
3695                 add_line_text(view, "External commands:", LINE_DEFAULT);
3696         }
3697
3698         for (i = 0; i < run_requests; i++) {
3699                 struct run_request *req = get_run_request(REQ_NONE + i + 1);
3700                 const char *key;
3701                 int argc;
3702
3703                 if (!req)
3704                         continue;
3705
3706                 key = get_key_name(req->key);
3707                 if (!*key)
3708                         key = "(no key defined)";
3709
3710                 for (bufpos = 0, argc = 0; req->argv[argc]; argc++)
3711                         if (!string_format_from(buf, &bufpos, "%s%s",
3712                                                 argc ? " " : "", req->argv[argc]))
3713                                 return REQ_NONE;
3714
3715                 add_line_format(view, LINE_DEFAULT, "    %-10s %-14s `%s`",
3716                                 keymap_table[req->keymap].name, key, buf);
3717         }
3718
3719         return TRUE;
3720 }
3721
3722 static struct view_ops help_ops = {
3723         "line",
3724         NULL,
3725         help_open,
3726         NULL,
3727         pager_draw,
3728         pager_request,
3729         pager_grep,
3730         pager_select,
3731 };
3732
3733
3734 /*
3735  * Tree backend
3736  */
3737
3738 struct tree_stack_entry {
3739         struct tree_stack_entry *prev;  /* Entry below this in the stack */
3740         unsigned long lineno;           /* Line number to restore */
3741         char *name;                     /* Position of name in opt_path */
3742 };
3743
3744 /* The top of the path stack. */
3745 static struct tree_stack_entry *tree_stack = NULL;
3746 unsigned long tree_lineno = 0;
3747
3748 static void
3749 pop_tree_stack_entry(void)
3750 {
3751         struct tree_stack_entry *entry = tree_stack;
3752
3753         tree_lineno = entry->lineno;
3754         entry->name[0] = 0;
3755         tree_stack = entry->prev;
3756         free(entry);
3757 }
3758
3759 static void
3760 push_tree_stack_entry(const char *name, unsigned long lineno)
3761 {
3762         struct tree_stack_entry *entry = calloc(1, sizeof(*entry));
3763         size_t pathlen = strlen(opt_path);
3764
3765         if (!entry)
3766                 return;
3767
3768         entry->prev = tree_stack;
3769         entry->name = opt_path + pathlen;
3770         tree_stack = entry;
3771
3772         if (!string_format_from(opt_path, &pathlen, "%s/", name)) {
3773                 pop_tree_stack_entry();
3774                 return;
3775         }
3776
3777         /* Move the current line to the first tree entry. */
3778         tree_lineno = 1;
3779         entry->lineno = lineno;
3780 }
3781
3782 /* Parse output from git-ls-tree(1):
3783  *
3784  * 100644 blob fb0e31ea6cc679b7379631188190e975f5789c26 Makefile
3785  * 100644 blob 5304ca4260aaddaee6498f9630e7d471b8591ea6 README
3786  * 100644 blob f931e1d229c3e185caad4449bf5b66ed72462657 tig.c
3787  * 100644 blob ed09fe897f3c7c9af90bcf80cae92558ea88ae38 web.conf
3788  */
3789
3790 #define SIZEOF_TREE_ATTR \
3791         STRING_SIZE("100644 blob ed09fe897f3c7c9af90bcf80cae92558ea88ae38\t")
3792
3793 #define SIZEOF_TREE_MODE \
3794         STRING_SIZE("100644 ")
3795
3796 #define TREE_ID_OFFSET \
3797         STRING_SIZE("100644 blob ")
3798
3799 struct tree_entry {
3800         char id[SIZEOF_REV];
3801         mode_t mode;
3802         struct tm time;                 /* Date from the author ident. */
3803         char author[75];                /* Author of the commit. */
3804         char name[1];
3805 };
3806
3807 static const char *
3808 tree_path(struct line *line)
3809 {
3810         return ((struct tree_entry *) line->data)->name;
3811 }
3812
3813
3814 static int
3815 tree_compare_entry(struct line *line1, struct line *line2)
3816 {
3817         if (line1->type != line2->type)
3818                 return line1->type == LINE_TREE_DIR ? -1 : 1;
3819         return strcmp(tree_path(line1), tree_path(line2));
3820 }
3821
3822 static struct line *
3823 tree_entry(struct view *view, enum line_type type, const char *path,
3824            const char *mode, const char *id)
3825 {
3826         struct tree_entry *entry = calloc(1, sizeof(*entry) + strlen(path));
3827         struct line *line = entry ? add_line_data(view, entry, type) : NULL;
3828
3829         if (!entry || !line) {
3830                 free(entry);
3831                 return NULL;
3832         }
3833
3834         strncpy(entry->name, path, strlen(path));
3835         if (mode)
3836                 entry->mode = strtoul(mode, NULL, 8);
3837         if (id)
3838                 string_copy_rev(entry->id, id);
3839
3840         return line;
3841 }
3842
3843 static bool
3844 tree_read_date(struct view *view, char *text, bool *read_date)
3845 {
3846         static char author_name[SIZEOF_STR];
3847         static struct tm author_time;
3848
3849         if (!text && *read_date) {
3850                 *read_date = FALSE;
3851                 return TRUE;
3852
3853         } else if (!text) {
3854                 char *path = *opt_path ? opt_path : ".";
3855                 /* Find next entry to process */
3856                 const char *log_file[] = {
3857                         "git", "log", "--no-color", "--pretty=raw",
3858                                 "--cc", "--raw", view->id, "--", path, NULL
3859                 };
3860                 struct io io = {};
3861
3862                 if (!view->lines) {
3863                         tree_entry(view, LINE_TREE_HEAD, opt_path, NULL, NULL);
3864                         report("Tree is empty");
3865                         return TRUE;
3866                 }
3867
3868                 if (!run_io_rd(&io, log_file, FORMAT_NONE)) {
3869                         report("Failed to load tree data");
3870                         return TRUE;
3871                 }
3872
3873                 done_io(view->pipe);
3874                 view->io = io;
3875                 *read_date = TRUE;
3876                 return FALSE;
3877
3878         } else if (*text == 'a' && get_line_type(text) == LINE_AUTHOR) {
3879                 parse_author_line(text + STRING_SIZE("author "),
3880                                   author_name, sizeof(author_name), &author_time);
3881
3882         } else if (*text == ':') {
3883                 char *pos;
3884                 size_t annotated = 1;
3885                 size_t i;
3886
3887                 pos = strchr(text, '\t');
3888                 if (!pos)
3889                         return TRUE;
3890                 text = pos + 1;
3891                 if (*opt_prefix && !strncmp(text, opt_prefix, strlen(opt_prefix)))
3892                         text += strlen(opt_prefix);
3893                 if (*opt_path && !strncmp(text, opt_path, strlen(opt_path)))
3894                         text += strlen(opt_path);
3895                 pos = strchr(text, '/');
3896                 if (pos)
3897                         *pos = 0;
3898
3899                 for (i = 1; i < view->lines; i++) {
3900                         struct line *line = &view->line[i];
3901                         struct tree_entry *entry = line->data;
3902
3903                         annotated += !!*entry->author;
3904                         if (*entry->author || strcmp(entry->name, text))
3905                                 continue;
3906
3907                         string_copy(entry->author, author_name);
3908                         memcpy(&entry->time, &author_time, sizeof(entry->time));
3909                         line->dirty = 1;
3910                         break;
3911                 }
3912
3913                 if (annotated == view->lines)
3914                         kill_io(view->pipe);
3915         }
3916         return TRUE;
3917 }
3918
3919 static bool
3920 tree_read(struct view *view, char *text)
3921 {
3922         static bool read_date = FALSE;
3923         struct tree_entry *data;
3924         struct line *entry, *line;
3925         enum line_type type;
3926         size_t textlen = text ? strlen(text) : 0;
3927         char *path = text + SIZEOF_TREE_ATTR;
3928
3929         if (read_date || !text)
3930                 return tree_read_date(view, text, &read_date);
3931
3932         if (textlen <= SIZEOF_TREE_ATTR)
3933                 return FALSE;
3934         if (view->lines == 0 &&
3935             !tree_entry(view, LINE_TREE_HEAD, opt_path, NULL, NULL))
3936                 return FALSE;
3937
3938         /* Strip the path part ... */
3939         if (*opt_path) {
3940                 size_t pathlen = textlen - SIZEOF_TREE_ATTR;
3941                 size_t striplen = strlen(opt_path);
3942
3943                 if (pathlen > striplen)
3944                         memmove(path, path + striplen,
3945                                 pathlen - striplen + 1);
3946
3947                 /* Insert "link" to parent directory. */
3948                 if (view->lines == 1 &&
3949                     !tree_entry(view, LINE_TREE_DIR, "..", "040000", view->ref))
3950                         return FALSE;
3951         }
3952
3953         type = text[SIZEOF_TREE_MODE] == 't' ? LINE_TREE_DIR : LINE_TREE_FILE;
3954         entry = tree_entry(view, type, path, text, text + TREE_ID_OFFSET);
3955         if (!entry)
3956                 return FALSE;
3957         data = entry->data;
3958
3959         /* Skip "Directory ..." and ".." line. */
3960         for (line = &view->line[1 + !!*opt_path]; line < entry; line++) {
3961                 if (tree_compare_entry(line, entry) <= 0)
3962                         continue;
3963
3964                 memmove(line + 1, line, (entry - line) * sizeof(*entry));
3965
3966                 line->data = data;
3967                 line->type = type;
3968                 for (; line <= entry; line++)
3969                         line->dirty = line->cleareol = 1;
3970                 return TRUE;
3971         }
3972
3973         if (tree_lineno > view->lineno) {
3974                 view->lineno = tree_lineno;
3975                 tree_lineno = 0;
3976         }
3977
3978         return TRUE;
3979 }
3980
3981 static bool
3982 tree_draw(struct view *view, struct line *line, unsigned int lineno)
3983 {
3984         struct tree_entry *entry = line->data;
3985
3986         if (line->type == LINE_TREE_HEAD) {
3987                 if (draw_text(view, line->type, "Directory path /", TRUE))
3988                         return TRUE;
3989         } else {
3990                 if (draw_mode(view, entry->mode))
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 *unmerged = NULL;
4624         char *buf;
4625         struct io io = {};
4626
4627         if (!run_io(&io, argv, NULL, IO_RD))
4628                 return FALSE;
4629
4630         add_line_data(view, NULL, type);
4631
4632         while ((buf = io_get(&io, 0, TRUE))) {
4633                 struct status *file = unmerged;
4634
4635                 if (!file) {
4636                         file = calloc(1, sizeof(*file));
4637                         if (!file || !add_line_data(view, file, type))
4638                                 goto error_out;
4639                 }
4640
4641                 /* Parse diff info part. */
4642                 if (status) {
4643                         file->status = status;
4644                         if (status == 'A')
4645                                 string_copy(file->old.rev, NULL_ID);
4646
4647                 } else if (!file->status || file == unmerged) {
4648                         if (!status_get_diff(file, buf, strlen(buf)))
4649                                 goto error_out;
4650
4651                         buf = io_get(&io, 0, TRUE);
4652                         if (!buf)
4653                                 break;
4654
4655                         /* Collapse all 'M'odified entries that follow a
4656                          * associated 'U'nmerged entry. */
4657                         if (unmerged == file) {
4658                                 unmerged->status = 'U';
4659                                 unmerged = NULL;
4660                         } else if (file->status == 'U') {
4661                                 unmerged = file;
4662                         }
4663                 }
4664
4665                 /* Grab the old name for rename/copy. */
4666                 if (!*file->old.name &&
4667                     (file->status == 'R' || file->status == 'C')) {
4668                         string_ncopy(file->old.name, buf, strlen(buf));
4669
4670                         buf = io_get(&io, 0, TRUE);
4671                         if (!buf)
4672                                 break;
4673                 }
4674
4675                 /* git-ls-files just delivers a NUL separated list of
4676                  * file names similar to the second half of the
4677                  * git-diff-* output. */
4678                 string_ncopy(file->new.name, buf, strlen(buf));
4679                 if (!*file->old.name)
4680                         string_copy(file->old.name, file->new.name);
4681                 file = NULL;
4682         }
4683
4684         if (io_error(&io)) {
4685 error_out:
4686                 done_io(&io);
4687                 return FALSE;
4688         }
4689
4690         if (!view->line[view->lines - 1].data)
4691                 add_line_data(view, NULL, LINE_STAT_NONE);
4692
4693         done_io(&io);
4694         return TRUE;
4695 }
4696
4697 /* Don't show unmerged entries in the staged section. */
4698 static const char *status_diff_index_argv[] = {
4699         "git", "diff-index", "-z", "--diff-filter=ACDMRTXB",
4700                              "--cached", "-M", "HEAD", NULL
4701 };
4702
4703 static const char *status_diff_files_argv[] = {
4704         "git", "diff-files", "-z", NULL
4705 };
4706
4707 static const char *status_list_other_argv[] = {
4708         "git", "ls-files", "-z", "--others", "--exclude-standard", NULL
4709 };
4710
4711 static const char *status_list_no_head_argv[] = {
4712         "git", "ls-files", "-z", "--cached", "--exclude-standard", NULL
4713 };
4714
4715 static const char *update_index_argv[] = {
4716         "git", "update-index", "-q", "--unmerged", "--refresh", NULL
4717 };
4718
4719 /* Restore the previous line number to stay in the context or select a
4720  * line with something that can be updated. */
4721 static void
4722 status_restore(struct view *view)
4723 {
4724         if (view->p_lineno >= view->lines)
4725                 view->p_lineno = view->lines - 1;
4726         while (view->p_lineno < view->lines && !view->line[view->p_lineno].data)
4727                 view->p_lineno++;
4728         while (view->p_lineno > 0 && !view->line[view->p_lineno].data)
4729                 view->p_lineno--;
4730
4731         /* If the above fails, always skip the "On branch" line. */
4732         if (view->p_lineno < view->lines)
4733                 view->lineno = view->p_lineno;
4734         else
4735                 view->lineno = 1;
4736
4737         if (view->lineno < view->offset)
4738                 view->offset = view->lineno;
4739         else if (view->offset + view->height <= view->lineno)
4740                 view->offset = view->lineno - view->height + 1;
4741
4742         view->p_restore = FALSE;
4743 }
4744
4745 /* First parse staged info using git-diff-index(1), then parse unstaged
4746  * info using git-diff-files(1), and finally untracked files using
4747  * git-ls-files(1). */
4748 static bool
4749 status_open(struct view *view)
4750 {
4751         reset_view(view);
4752
4753         add_line_data(view, NULL, LINE_STAT_HEAD);
4754         if (is_initial_commit())
4755                 string_copy(status_onbranch, "Initial commit");
4756         else if (!*opt_head)
4757                 string_copy(status_onbranch, "Not currently on any branch");
4758         else if (!string_format(status_onbranch, "On branch %s", opt_head))
4759                 return FALSE;
4760
4761         run_io_bg(update_index_argv);
4762
4763         if (is_initial_commit()) {
4764                 if (!status_run(view, status_list_no_head_argv, 'A', LINE_STAT_STAGED))
4765                         return FALSE;
4766         } else if (!status_run(view, status_diff_index_argv, 0, LINE_STAT_STAGED)) {
4767                 return FALSE;
4768         }
4769
4770         if (!status_run(view, status_diff_files_argv, 0, LINE_STAT_UNSTAGED) ||
4771             !status_run(view, status_list_other_argv, '?', LINE_STAT_UNTRACKED))
4772                 return FALSE;
4773
4774         /* Restore the exact position or use the specialized restore
4775          * mode? */
4776         if (!view->p_restore)
4777                 status_restore(view);
4778         return TRUE;
4779 }
4780
4781 static bool
4782 status_draw(struct view *view, struct line *line, unsigned int lineno)
4783 {
4784         struct status *status = line->data;
4785         enum line_type type;
4786         const char *text;
4787
4788         if (!status) {
4789                 switch (line->type) {
4790                 case LINE_STAT_STAGED:
4791                         type = LINE_STAT_SECTION;
4792                         text = "Changes to be committed:";
4793                         break;
4794
4795                 case LINE_STAT_UNSTAGED:
4796                         type = LINE_STAT_SECTION;
4797                         text = "Changed but not updated:";
4798                         break;
4799
4800                 case LINE_STAT_UNTRACKED:
4801                         type = LINE_STAT_SECTION;
4802                         text = "Untracked files:";
4803                         break;
4804
4805                 case LINE_STAT_NONE:
4806                         type = LINE_DEFAULT;
4807                         text = "  (no files)";
4808                         break;
4809
4810                 case LINE_STAT_HEAD:
4811                         type = LINE_STAT_HEAD;
4812                         text = status_onbranch;
4813                         break;
4814
4815                 default:
4816                         return FALSE;
4817                 }
4818         } else {
4819                 static char buf[] = { '?', ' ', ' ', ' ', 0 };
4820
4821                 buf[0] = status->status;
4822                 if (draw_text(view, line->type, buf, TRUE))
4823                         return TRUE;
4824                 type = LINE_DEFAULT;
4825                 text = status->new.name;
4826         }
4827
4828         draw_text(view, type, text, TRUE);
4829         return TRUE;
4830 }
4831
4832 static enum request
4833 status_enter(struct view *view, struct line *line)
4834 {
4835         struct status *status = line->data;
4836         const char *oldpath = status ? status->old.name : NULL;
4837         /* Diffs for unmerged entries are empty when passing the new
4838          * path, so leave it empty. */
4839         const char *newpath = status && status->status != 'U' ? status->new.name : NULL;
4840         const char *info;
4841         enum open_flags split;
4842         struct view *stage = VIEW(REQ_VIEW_STAGE);
4843
4844         if (line->type == LINE_STAT_NONE ||
4845             (!status && line[1].type == LINE_STAT_NONE)) {
4846                 report("No file to diff");
4847                 return REQ_NONE;
4848         }
4849
4850         switch (line->type) {
4851         case LINE_STAT_STAGED:
4852                 if (is_initial_commit()) {
4853                         const char *no_head_diff_argv[] = {
4854                                 "git", "diff", "--no-color", "--patch-with-stat",
4855                                         "--", "/dev/null", newpath, NULL
4856                         };
4857
4858                         if (!prepare_update(stage, no_head_diff_argv, opt_cdup, FORMAT_DASH))
4859                                 return REQ_QUIT;
4860                 } else {
4861                         const char *index_show_argv[] = {
4862                                 "git", "diff-index", "--root", "--patch-with-stat",
4863                                         "-C", "-M", "--cached", "HEAD", "--",
4864                                         oldpath, newpath, NULL
4865                         };
4866
4867                         if (!prepare_update(stage, index_show_argv, opt_cdup, FORMAT_DASH))
4868                                 return REQ_QUIT;
4869                 }
4870
4871                 if (status)
4872                         info = "Staged changes to %s";
4873                 else
4874                         info = "Staged changes";
4875                 break;
4876
4877         case LINE_STAT_UNSTAGED:
4878         {
4879                 const char *files_show_argv[] = {
4880                         "git", "diff-files", "--root", "--patch-with-stat",
4881                                 "-C", "-M", "--", oldpath, newpath, NULL
4882                 };
4883
4884                 if (!prepare_update(stage, files_show_argv, opt_cdup, FORMAT_DASH))
4885                         return REQ_QUIT;
4886                 if (status)
4887                         info = "Unstaged changes to %s";
4888                 else
4889                         info = "Unstaged changes";
4890                 break;
4891         }
4892         case LINE_STAT_UNTRACKED:
4893                 if (!newpath) {
4894                         report("No file to show");
4895                         return REQ_NONE;
4896                 }
4897
4898                 if (!suffixcmp(status->new.name, -1, "/")) {
4899                         report("Cannot display a directory");
4900                         return REQ_NONE;
4901                 }
4902
4903                 if (!prepare_update_file(stage, newpath))
4904                         return REQ_QUIT;
4905                 info = "Untracked file %s";
4906                 break;
4907
4908         case LINE_STAT_HEAD:
4909                 return REQ_NONE;
4910
4911         default:
4912                 die("line type %d not handled in switch", line->type);
4913         }
4914
4915         split = view_is_displayed(view) ? OPEN_SPLIT : 0;
4916         open_view(view, REQ_VIEW_STAGE, OPEN_PREPARED | split);
4917         if (view_is_displayed(VIEW(REQ_VIEW_STAGE))) {
4918                 if (status) {
4919                         stage_status = *status;
4920                 } else {
4921                         memset(&stage_status, 0, sizeof(stage_status));
4922                 }
4923
4924                 stage_line_type = line->type;
4925                 stage_chunks = 0;
4926                 string_format(VIEW(REQ_VIEW_STAGE)->ref, info, stage_status.new.name);
4927         }
4928
4929         return REQ_NONE;
4930 }
4931
4932 static bool
4933 status_exists(struct status *status, enum line_type type)
4934 {
4935         struct view *view = VIEW(REQ_VIEW_STATUS);
4936         unsigned long lineno;
4937
4938         for (lineno = 0; lineno < view->lines; lineno++) {
4939                 struct line *line = &view->line[lineno];
4940                 struct status *pos = line->data;
4941
4942                 if (line->type != type)
4943                         continue;
4944                 if (!pos && (!status || !status->status) && line[1].data) {
4945                         select_view_line(view, lineno);
4946                         return TRUE;
4947                 }
4948                 if (pos && !strcmp(status->new.name, pos->new.name)) {
4949                         select_view_line(view, lineno);
4950                         return TRUE;
4951                 }
4952         }
4953
4954         return FALSE;
4955 }
4956
4957
4958 static bool
4959 status_update_prepare(struct io *io, enum line_type type)
4960 {
4961         const char *staged_argv[] = {
4962                 "git", "update-index", "-z", "--index-info", NULL
4963         };
4964         const char *others_argv[] = {
4965                 "git", "update-index", "-z", "--add", "--remove", "--stdin", NULL
4966         };
4967
4968         switch (type) {
4969         case LINE_STAT_STAGED:
4970                 return run_io(io, staged_argv, opt_cdup, IO_WR);
4971
4972         case LINE_STAT_UNSTAGED:
4973                 return run_io(io, others_argv, opt_cdup, IO_WR);
4974
4975         case LINE_STAT_UNTRACKED:
4976                 return run_io(io, others_argv, NULL, IO_WR);
4977
4978         default:
4979                 die("line type %d not handled in switch", type);
4980                 return FALSE;
4981         }
4982 }
4983
4984 static bool
4985 status_update_write(struct io *io, struct status *status, enum line_type type)
4986 {
4987         char buf[SIZEOF_STR];
4988         size_t bufsize = 0;
4989
4990         switch (type) {
4991         case LINE_STAT_STAGED:
4992                 if (!string_format_from(buf, &bufsize, "%06o %s\t%s%c",
4993                                         status->old.mode,
4994                                         status->old.rev,
4995                                         status->old.name, 0))
4996                         return FALSE;
4997                 break;
4998
4999         case LINE_STAT_UNSTAGED:
5000         case LINE_STAT_UNTRACKED:
5001                 if (!string_format_from(buf, &bufsize, "%s%c", status->new.name, 0))
5002                         return FALSE;
5003                 break;
5004
5005         default:
5006                 die("line type %d not handled in switch", type);
5007         }
5008
5009         return io_write(io, buf, bufsize);
5010 }
5011
5012 static bool
5013 status_update_file(struct status *status, enum line_type type)
5014 {
5015         struct io io = {};
5016         bool result;
5017
5018         if (!status_update_prepare(&io, type))
5019                 return FALSE;
5020
5021         result = status_update_write(&io, status, type);
5022         done_io(&io);
5023         return result;
5024 }
5025
5026 static bool
5027 status_update_files(struct view *view, struct line *line)
5028 {
5029         struct io io = {};
5030         bool result = TRUE;
5031         struct line *pos = view->line + view->lines;
5032         int files = 0;
5033         int file, done;
5034
5035         if (!status_update_prepare(&io, line->type))
5036                 return FALSE;
5037
5038         for (pos = line; pos < view->line + view->lines && pos->data; pos++)
5039                 files++;
5040
5041         for (file = 0, done = 0; result && file < files; line++, file++) {
5042                 int almost_done = file * 100 / files;
5043
5044                 if (almost_done > done) {
5045                         done = almost_done;
5046                         string_format(view->ref, "updating file %u of %u (%d%% done)",
5047                                       file, files, done);
5048                         update_view_title(view);
5049                 }
5050                 result = status_update_write(&io, line->data, line->type);
5051         }
5052
5053         done_io(&io);
5054         return result;
5055 }
5056
5057 static bool
5058 status_update(struct view *view)
5059 {
5060         struct line *line = &view->line[view->lineno];
5061
5062         assert(view->lines);
5063
5064         if (!line->data) {
5065                 /* This should work even for the "On branch" line. */
5066                 if (line < view->line + view->lines && !line[1].data) {
5067                         report("Nothing to update");
5068                         return FALSE;
5069                 }
5070
5071                 if (!status_update_files(view, line + 1)) {
5072                         report("Failed to update file status");
5073                         return FALSE;
5074                 }
5075
5076         } else if (!status_update_file(line->data, line->type)) {
5077                 report("Failed to update file status");
5078                 return FALSE;
5079         }
5080
5081         return TRUE;
5082 }
5083
5084 static bool
5085 status_revert(struct status *status, enum line_type type, bool has_none)
5086 {
5087         if (!status || type != LINE_STAT_UNSTAGED) {
5088                 if (type == LINE_STAT_STAGED) {
5089                         report("Cannot revert changes to staged files");
5090                 } else if (type == LINE_STAT_UNTRACKED) {
5091                         report("Cannot revert changes to untracked files");
5092                 } else if (has_none) {
5093                         report("Nothing to revert");
5094                 } else {
5095                         report("Cannot revert changes to multiple files");
5096                 }
5097                 return FALSE;
5098
5099         } else {
5100                 char mode[10] = "100644";
5101                 const char *reset_argv[] = {
5102                         "git", "update-index", "--cacheinfo", mode,
5103                                 status->old.rev, status->old.name, NULL
5104                 };
5105                 const char *checkout_argv[] = {
5106                         "git", "checkout", "--", status->old.name, NULL
5107                 };
5108
5109                 if (!prompt_yesno("Are you sure you want to overwrite any changes?"))
5110                         return FALSE;
5111                 string_format(mode, "%o", status->old.mode);
5112                 return (status->status != 'U' || run_io_fg(reset_argv, opt_cdup)) &&
5113                         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 const char usage[] =
6714 "tig " TIG_VERSION " (" __DATE__ ")\n"
6715 "\n"
6716 "Usage: tig        [options] [revs] [--] [paths]\n"
6717 "   or: tig show   [options] [revs] [--] [paths]\n"
6718 "   or: tig blame  [rev] path\n"
6719 "   or: tig status\n"
6720 "   or: tig <      [git command output]\n"
6721 "\n"
6722 "Options:\n"
6723 "  -v, --version   Show version and exit\n"
6724 "  -h, --help      Show help message and exit";
6725
6726 static void __NORETURN
6727 quit(int sig)
6728 {
6729         /* XXX: Restore tty modes and let the OS cleanup the rest! */
6730         if (cursed)
6731                 endwin();
6732         exit(0);
6733 }
6734
6735 static void __NORETURN
6736 die(const char *err, ...)
6737 {
6738         va_list args;
6739
6740         endwin();
6741
6742         va_start(args, err);
6743         fputs("tig: ", stderr);
6744         vfprintf(stderr, err, args);
6745         fputs("\n", stderr);
6746         va_end(args);
6747
6748         exit(1);
6749 }
6750
6751 static void
6752 warn(const char *msg, ...)
6753 {
6754         va_list args;
6755
6756         va_start(args, msg);
6757         fputs("tig warning: ", stderr);
6758         vfprintf(stderr, msg, args);
6759         fputs("\n", stderr);
6760         va_end(args);
6761 }
6762
6763 static enum request
6764 parse_options(int argc, const char *argv[])
6765 {
6766         enum request request = REQ_VIEW_MAIN;
6767         const char *subcommand;
6768         bool seen_dashdash = FALSE;
6769         /* XXX: This is vulnerable to the user overriding options
6770          * required for the main view parser. */
6771         const char *custom_argv[SIZEOF_ARG] = {
6772                 "git", "log", "--no-color", "--pretty=raw", "--parents",
6773                         "--topo-order", NULL
6774         };
6775         int i, j = 6;
6776
6777         if (!isatty(STDIN_FILENO)) {
6778                 io_open(&VIEW(REQ_VIEW_PAGER)->io, "");
6779                 return REQ_VIEW_PAGER;
6780         }
6781
6782         if (argc <= 1)
6783                 return REQ_NONE;
6784
6785         subcommand = argv[1];
6786         if (!strcmp(subcommand, "status")) {
6787                 if (argc > 2)
6788                         warn("ignoring arguments after `%s'", subcommand);
6789                 return REQ_VIEW_STATUS;
6790
6791         } else if (!strcmp(subcommand, "blame")) {
6792                 if (argc <= 2 || argc > 4)
6793                         die("invalid number of options to blame\n\n%s", usage);
6794
6795                 i = 2;
6796                 if (argc == 4) {
6797                         string_ncopy(opt_ref, argv[i], strlen(argv[i]));
6798                         i++;
6799                 }
6800
6801                 string_ncopy(opt_file, argv[i], strlen(argv[i]));
6802                 return REQ_VIEW_BLAME;
6803
6804         } else if (!strcmp(subcommand, "show")) {
6805                 request = REQ_VIEW_DIFF;
6806
6807         } else {
6808                 subcommand = NULL;
6809         }
6810
6811         if (subcommand) {
6812                 custom_argv[1] = subcommand;
6813                 j = 2;
6814         }
6815
6816         for (i = 1 + !!subcommand; i < argc; i++) {
6817                 const char *opt = argv[i];
6818
6819                 if (seen_dashdash || !strcmp(opt, "--")) {
6820                         seen_dashdash = TRUE;
6821
6822                 } else if (!strcmp(opt, "-v") || !strcmp(opt, "--version")) {
6823                         printf("tig version %s\n", TIG_VERSION);
6824                         quit(0);
6825
6826                 } else if (!strcmp(opt, "-h") || !strcmp(opt, "--help")) {
6827                         printf("%s\n", usage);
6828                         quit(0);
6829                 }
6830
6831                 custom_argv[j++] = opt;
6832                 if (j >= ARRAY_SIZE(custom_argv))
6833                         die("command too long");
6834         }
6835
6836         if (!prepare_update(VIEW(request), custom_argv, NULL, FORMAT_NONE))
6837                 die("Failed to format arguments");
6838
6839         return request;
6840 }
6841
6842 int
6843 main(int argc, const char *argv[])
6844 {
6845         enum request request = parse_options(argc, argv);
6846         struct view *view;
6847         size_t i;
6848
6849         signal(SIGINT, quit);
6850
6851         if (setlocale(LC_ALL, "")) {
6852                 char *codeset = nl_langinfo(CODESET);
6853
6854                 string_ncopy(opt_codeset, codeset, strlen(codeset));
6855         }
6856
6857         if (load_repo_info() == ERR)
6858                 die("Failed to load repo info.");
6859
6860         if (load_options() == ERR)
6861                 die("Failed to load user config.");
6862
6863         if (load_git_config() == ERR)
6864                 die("Failed to load repo config.");
6865
6866         /* Require a git repository unless when running in pager mode. */
6867         if (!opt_git_dir[0] && request != REQ_VIEW_PAGER)
6868                 die("Not a git repository");
6869
6870         if (*opt_encoding && strcasecmp(opt_encoding, "UTF-8"))
6871                 opt_utf8 = FALSE;
6872
6873         if (*opt_codeset && strcmp(opt_codeset, opt_encoding)) {
6874                 opt_iconv = iconv_open(opt_codeset, opt_encoding);
6875                 if (opt_iconv == ICONV_NONE)
6876                         die("Failed to initialize character set conversion");
6877         }
6878
6879         if (load_refs() == ERR)
6880                 die("Failed to load refs.");
6881
6882         foreach_view (view, i)
6883                 argv_from_env(view->ops->argv, view->cmd_env);
6884
6885         init_display();
6886
6887         if (request != REQ_NONE)
6888                 open_view(NULL, request, OPEN_PREPARED);
6889         request = request == REQ_NONE ? REQ_VIEW_MAIN : REQ_NONE;
6890
6891         while (view_driver(display[current_view], request)) {
6892                 int key = get_input(0);
6893
6894                 view = display[current_view];
6895                 request = get_keybinding(view->keymap, key);
6896
6897                 /* Some low-level request handling. This keeps access to
6898                  * status_win restricted. */
6899                 switch (request) {
6900                 case REQ_PROMPT:
6901                 {
6902                         char *cmd = read_prompt(":");
6903
6904                         if (cmd) {
6905                                 struct view *next = VIEW(REQ_VIEW_PAGER);
6906                                 const char *argv[SIZEOF_ARG] = { "git" };
6907                                 int argc = 1;
6908
6909                                 /* When running random commands, initially show the
6910                                  * command in the title. However, it maybe later be
6911                                  * overwritten if a commit line is selected. */
6912                                 string_ncopy(next->ref, cmd, strlen(cmd));
6913
6914                                 if (!argv_from_string(argv, &argc, cmd)) {
6915                                         report("Too many arguments");
6916                                 } else if (!prepare_update(next, argv, NULL, FORMAT_DASH)) {
6917                                         report("Failed to format command");
6918                                 } else {
6919                                         open_view(view, REQ_VIEW_PAGER, OPEN_PREPARED);
6920                                 }
6921                         }
6922
6923                         request = REQ_NONE;
6924                         break;
6925                 }
6926                 case REQ_SEARCH:
6927                 case REQ_SEARCH_BACK:
6928                 {
6929                         const char *prompt = request == REQ_SEARCH ? "/" : "?";
6930                         char *search = read_prompt(prompt);
6931
6932                         if (search)
6933                                 string_ncopy(opt_search, search, strlen(search));
6934                         else if (*opt_search)
6935                                 request = request == REQ_SEARCH ?
6936                                         REQ_FIND_NEXT :
6937                                         REQ_FIND_PREV;
6938                         else
6939                                 request = REQ_NONE;
6940                         break;
6941                 }
6942                 default:
6943                         break;
6944                 }
6945         }
6946
6947         quit(0);
6948
6949         return 0;
6950 }