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

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