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