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 follow a
4267                          * associated 'U'nmerged entry. */
4268                         if (file->status == 'U') {
4269                                 unmerged = file;
4270
4271                         } else if (unmerged) {
4272                                 int collapse = !strcmp(buf, unmerged->new.name);
4273
4274                                 unmerged = NULL;
4275                                 if (collapse) {
4276                                         free(file);
4277                                         view->lines--;
4278                                         continue;
4279                                 }
4280                         }
4281                 }
4282
4283                 /* Grab the old name for rename/copy. */
4284                 if (!*file->old.name &&
4285                     (file->status == 'R' || file->status == 'C')) {
4286                         string_ncopy(file->old.name, buf, strlen(buf));
4287
4288                         buf = io_get(&io, 0, TRUE);
4289                         if (!buf)
4290                                 break;
4291                 }
4292
4293                 /* git-ls-files just delivers a NUL separated list of
4294                  * file names similar to the second half of the
4295                  * git-diff-* output. */
4296                 string_ncopy(file->new.name, buf, strlen(buf));
4297                 if (!*file->old.name)
4298                         string_copy(file->old.name, file->new.name);
4299                 file = NULL;
4300         }
4301
4302         if (io_error(&io)) {
4303 error_out:
4304                 done_io(&io);
4305                 return FALSE;
4306         }
4307
4308         if (!view->line[view->lines - 1].data)
4309                 add_line_data(view, NULL, LINE_STAT_NONE);
4310
4311         done_io(&io);
4312         return TRUE;
4313 }
4314
4315 /* Don't show unmerged entries in the staged section. */
4316 static const char *status_diff_index_argv[] = {
4317         "git", "diff-index", "-z", "--diff-filter=ACDMRTXB",
4318                              "--cached", "-M", "HEAD", NULL
4319 };
4320
4321 static const char *status_diff_files_argv[] = {
4322         "git", "diff-files", "-z", NULL
4323 };
4324
4325 static const char *status_list_other_argv[] = {
4326         "git", "ls-files", "-z", "--others", "--exclude-standard", NULL
4327 };
4328
4329 static const char *status_list_no_head_argv[] = {
4330         "git", "ls-files", "-z", "--cached", "--exclude-standard", NULL
4331 };
4332
4333 static const char *update_index_argv[] = {
4334         "git", "update-index", "-q", "--unmerged", "--refresh", NULL
4335 };
4336
4337 /* First parse staged info using git-diff-index(1), then parse unstaged
4338  * info using git-diff-files(1), and finally untracked files using
4339  * git-ls-files(1). */
4340 static bool
4341 status_open(struct view *view)
4342 {
4343         unsigned long prev_lineno = view->lineno;
4344
4345         reset_view(view);
4346
4347         if (!realloc_lines(view, view->line_size + 7))
4348                 return FALSE;
4349
4350         add_line_data(view, NULL, LINE_STAT_HEAD);
4351         if (is_initial_commit())
4352                 string_copy(status_onbranch, "Initial commit");
4353         else if (!*opt_head)
4354                 string_copy(status_onbranch, "Not currently on any branch");
4355         else if (!string_format(status_onbranch, "On branch %s", opt_head))
4356                 return FALSE;
4357
4358         run_io_bg(update_index_argv);
4359
4360         if (is_initial_commit()) {
4361                 if (!status_run(view, status_list_no_head_argv, 'A', LINE_STAT_STAGED))
4362                         return FALSE;
4363         } else if (!status_run(view, status_diff_index_argv, 0, LINE_STAT_STAGED)) {
4364                 return FALSE;
4365         }
4366
4367         if (!status_run(view, status_diff_files_argv, 0, LINE_STAT_UNSTAGED) ||
4368             !status_run(view, status_list_other_argv, '?', LINE_STAT_UNTRACKED))
4369                 return FALSE;
4370
4371         /* If all went well restore the previous line number to stay in
4372          * the context or select a line with something that can be
4373          * updated. */
4374         if (prev_lineno >= view->lines)
4375                 prev_lineno = view->lines - 1;
4376         while (prev_lineno < view->lines && !view->line[prev_lineno].data)
4377                 prev_lineno++;
4378         while (prev_lineno > 0 && !view->line[prev_lineno].data)
4379                 prev_lineno--;
4380
4381         /* If the above fails, always skip the "On branch" line. */
4382         if (prev_lineno < view->lines)
4383                 view->lineno = prev_lineno;
4384         else
4385                 view->lineno = 1;
4386
4387         if (view->lineno < view->offset)
4388                 view->offset = view->lineno;
4389         else if (view->offset + view->height <= view->lineno)
4390                 view->offset = view->lineno - view->height + 1;
4391
4392         return TRUE;
4393 }
4394
4395 static bool
4396 status_draw(struct view *view, struct line *line, unsigned int lineno)
4397 {
4398         struct status *status = line->data;
4399         enum line_type type;
4400         const char *text;
4401
4402         if (!status) {
4403                 switch (line->type) {
4404                 case LINE_STAT_STAGED:
4405                         type = LINE_STAT_SECTION;
4406                         text = "Changes to be committed:";
4407                         break;
4408
4409                 case LINE_STAT_UNSTAGED:
4410                         type = LINE_STAT_SECTION;
4411                         text = "Changed but not updated:";
4412                         break;
4413
4414                 case LINE_STAT_UNTRACKED:
4415                         type = LINE_STAT_SECTION;
4416                         text = "Untracked files:";
4417                         break;
4418
4419                 case LINE_STAT_NONE:
4420                         type = LINE_DEFAULT;
4421                         text = "    (no files)";
4422                         break;
4423
4424                 case LINE_STAT_HEAD:
4425                         type = LINE_STAT_HEAD;
4426                         text = status_onbranch;
4427                         break;
4428
4429                 default:
4430                         return FALSE;
4431                 }
4432         } else {
4433                 static char buf[] = { '?', ' ', ' ', ' ', 0 };
4434
4435                 buf[0] = status->status;
4436                 if (draw_text(view, line->type, buf, TRUE))
4437                         return TRUE;
4438                 type = LINE_DEFAULT;
4439                 text = status->new.name;
4440         }
4441
4442         draw_text(view, type, text, TRUE);
4443         return TRUE;
4444 }
4445
4446 static enum request
4447 status_enter(struct view *view, struct line *line)
4448 {
4449         struct status *status = line->data;
4450         const char *oldpath = status ? status->old.name : NULL;
4451         /* Diffs for unmerged entries are empty when passing the new
4452          * path, so leave it empty. */
4453         const char *newpath = status && status->status != 'U' ? status->new.name : NULL;
4454         const char *info;
4455         enum open_flags split;
4456         struct view *stage = VIEW(REQ_VIEW_STAGE);
4457
4458         if (line->type == LINE_STAT_NONE ||
4459             (!status && line[1].type == LINE_STAT_NONE)) {
4460                 report("No file to diff");
4461                 return REQ_NONE;
4462         }
4463
4464         switch (line->type) {
4465         case LINE_STAT_STAGED:
4466                 if (is_initial_commit()) {
4467                         const char *no_head_diff_argv[] = {
4468                                 "git", "diff", "--no-color", "--patch-with-stat",
4469                                         "--", "/dev/null", newpath, NULL
4470                         };
4471
4472                         if (!prepare_update(stage, no_head_diff_argv, opt_cdup, FORMAT_DASH))
4473                                 return REQ_QUIT;
4474                 } else {
4475                         const char *index_show_argv[] = {
4476                                 "git", "diff-index", "--root", "--patch-with-stat",
4477                                         "-C", "-M", "--cached", "HEAD", "--",
4478                                         oldpath, newpath, NULL
4479                         };
4480
4481                         if (!prepare_update(stage, index_show_argv, opt_cdup, FORMAT_DASH))
4482                                 return REQ_QUIT;
4483                 }
4484
4485                 if (status)
4486                         info = "Staged changes to %s";
4487                 else
4488                         info = "Staged changes";
4489                 break;
4490
4491         case LINE_STAT_UNSTAGED:
4492         {
4493                 const char *files_show_argv[] = {
4494                         "git", "diff-files", "--root", "--patch-with-stat",
4495                                 "-C", "-M", "--", oldpath, newpath, NULL
4496                 };
4497
4498                 if (!prepare_update(stage, files_show_argv, opt_cdup, FORMAT_DASH))
4499                         return REQ_QUIT;
4500                 if (status)
4501                         info = "Unstaged changes to %s";
4502                 else
4503                         info = "Unstaged changes";
4504                 break;
4505         }
4506         case LINE_STAT_UNTRACKED:
4507                 if (!newpath) {
4508                         report("No file to show");
4509                         return REQ_NONE;
4510                 }
4511
4512                 if (!suffixcmp(status->new.name, -1, "/")) {
4513                         report("Cannot display a directory");
4514                         return REQ_NONE;
4515                 }
4516
4517                 if (!prepare_update_file(stage, newpath))
4518                         return REQ_QUIT;
4519                 info = "Untracked file %s";
4520                 break;
4521
4522         case LINE_STAT_HEAD:
4523                 return REQ_NONE;
4524
4525         default:
4526                 die("line type %d not handled in switch", line->type);
4527         }
4528
4529         split = view_is_displayed(view) ? OPEN_SPLIT : 0;
4530         open_view(view, REQ_VIEW_STAGE, OPEN_REFRESH | split);
4531         if (view_is_displayed(VIEW(REQ_VIEW_STAGE))) {
4532                 if (status) {
4533                         stage_status = *status;
4534                 } else {
4535                         memset(&stage_status, 0, sizeof(stage_status));
4536                 }
4537
4538                 stage_line_type = line->type;
4539                 stage_chunks = 0;
4540                 string_format(VIEW(REQ_VIEW_STAGE)->ref, info, stage_status.new.name);
4541         }
4542
4543         return REQ_NONE;
4544 }
4545
4546 static bool
4547 status_exists(struct status *status, enum line_type type)
4548 {
4549         struct view *view = VIEW(REQ_VIEW_STATUS);
4550         struct line *line;
4551
4552         for (line = view->line; line < view->line + view->lines; line++) {
4553                 struct status *pos = line->data;
4554
4555                 if (line->type == type && pos &&
4556                     !strcmp(status->new.name, pos->new.name))
4557                         return TRUE;
4558         }
4559
4560         return FALSE;
4561 }
4562
4563
4564 static bool
4565 status_update_prepare(struct io *io, enum line_type type)
4566 {
4567         const char *staged_argv[] = {
4568                 "git", "update-index", "-z", "--index-info", NULL
4569         };
4570         const char *others_argv[] = {
4571                 "git", "update-index", "-z", "--add", "--remove", "--stdin", NULL
4572         };
4573
4574         switch (type) {
4575         case LINE_STAT_STAGED:
4576                 return run_io(io, staged_argv, opt_cdup, IO_WR);
4577
4578         case LINE_STAT_UNSTAGED:
4579                 return run_io(io, others_argv, opt_cdup, IO_WR);
4580
4581         case LINE_STAT_UNTRACKED:
4582                 return run_io(io, others_argv, NULL, IO_WR);
4583
4584         default:
4585                 die("line type %d not handled in switch", type);
4586                 return FALSE;
4587         }
4588 }
4589
4590 static bool
4591 status_update_write(struct io *io, struct status *status, enum line_type type)
4592 {
4593         char buf[SIZEOF_STR];
4594         size_t bufsize = 0;
4595
4596         switch (type) {
4597         case LINE_STAT_STAGED:
4598                 if (!string_format_from(buf, &bufsize, "%06o %s\t%s%c",
4599                                         status->old.mode,
4600                                         status->old.rev,
4601                                         status->old.name, 0))
4602                         return FALSE;
4603                 break;
4604
4605         case LINE_STAT_UNSTAGED:
4606         case LINE_STAT_UNTRACKED:
4607                 if (!string_format_from(buf, &bufsize, "%s%c", status->new.name, 0))
4608                         return FALSE;
4609                 break;
4610
4611         default:
4612                 die("line type %d not handled in switch", type);
4613         }
4614
4615         return io_write(io, buf, bufsize);
4616 }
4617
4618 static bool
4619 status_update_file(struct status *status, enum line_type type)
4620 {
4621         struct io io = {};
4622         bool result;
4623
4624         if (!status_update_prepare(&io, type))
4625                 return FALSE;
4626
4627         result = status_update_write(&io, status, type);
4628         done_io(&io);
4629         return result;
4630 }
4631
4632 static bool
4633 status_update_files(struct view *view, struct line *line)
4634 {
4635         struct io io = {};
4636         bool result = TRUE;
4637         struct line *pos = view->line + view->lines;
4638         int files = 0;
4639         int file, done;
4640
4641         if (!status_update_prepare(&io, line->type))
4642                 return FALSE;
4643
4644         for (pos = line; pos < view->line + view->lines && pos->data; pos++)
4645                 files++;
4646
4647         for (file = 0, done = 0; result && file < files; line++, file++) {
4648                 int almost_done = file * 100 / files;
4649
4650                 if (almost_done > done) {
4651                         done = almost_done;
4652                         string_format(view->ref, "updating file %u of %u (%d%% done)",
4653                                       file, files, done);
4654                         update_view_title(view);
4655                 }
4656                 result = status_update_write(&io, line->data, line->type);
4657         }
4658
4659         done_io(&io);
4660         return result;
4661 }
4662
4663 static bool
4664 status_update(struct view *view)
4665 {
4666         struct line *line = &view->line[view->lineno];
4667
4668         assert(view->lines);
4669
4670         if (!line->data) {
4671                 /* This should work even for the "On branch" line. */
4672                 if (line < view->line + view->lines && !line[1].data) {
4673                         report("Nothing to update");
4674                         return FALSE;
4675                 }
4676
4677                 if (!status_update_files(view, line + 1)) {
4678                         report("Failed to update file status");
4679                         return FALSE;
4680                 }
4681
4682         } else if (!status_update_file(line->data, line->type)) {
4683                 report("Failed to update file status");
4684                 return FALSE;
4685         }
4686
4687         return TRUE;
4688 }
4689
4690 static bool
4691 status_revert(struct status *status, enum line_type type, bool has_none)
4692 {
4693         if (!status || type != LINE_STAT_UNSTAGED) {
4694                 if (type == LINE_STAT_STAGED) {
4695                         report("Cannot revert changes to staged files");
4696                 } else if (type == LINE_STAT_UNTRACKED) {
4697                         report("Cannot revert changes to untracked files");
4698                 } else if (has_none) {
4699                         report("Nothing to revert");
4700                 } else {
4701                         report("Cannot revert changes to multiple files");
4702                 }
4703                 return FALSE;
4704
4705         } else {
4706                 const char *checkout_argv[] = {
4707                         "git", "checkout", "--", status->old.name, NULL
4708                 };
4709
4710                 if (!prompt_yesno("Are you sure you want to overwrite any changes?"))
4711                         return FALSE;
4712                 return run_io_fg(checkout_argv, opt_cdup);
4713         }
4714 }
4715
4716 static enum request
4717 status_request(struct view *view, enum request request, struct line *line)
4718 {
4719         struct status *status = line->data;
4720
4721         switch (request) {
4722         case REQ_STATUS_UPDATE:
4723                 if (!status_update(view))
4724                         return REQ_NONE;
4725                 break;
4726
4727         case REQ_STATUS_REVERT:
4728                 if (!status_revert(status, line->type, status_has_none(view, line)))
4729                         return REQ_NONE;
4730                 break;
4731
4732         case REQ_STATUS_MERGE:
4733                 if (!status || status->status != 'U') {
4734                         report("Merging only possible for files with unmerged status ('U').");
4735                         return REQ_NONE;
4736                 }
4737                 open_mergetool(status->new.name);
4738                 break;
4739
4740         case REQ_EDIT:
4741                 if (!status)
4742                         return request;
4743                 if (status->status == 'D') {
4744                         report("File has been deleted.");
4745                         return REQ_NONE;
4746                 }
4747
4748                 open_editor(status->status != '?', status->new.name);
4749                 break;
4750
4751         case REQ_VIEW_BLAME:
4752                 if (status) {
4753                         string_copy(opt_file, status->new.name);
4754                         opt_ref[0] = 0;
4755                 }
4756                 return request;
4757
4758         case REQ_ENTER:
4759                 /* After returning the status view has been split to
4760                  * show the stage view. No further reloading is
4761                  * necessary. */
4762                 status_enter(view, line);
4763                 return REQ_NONE;
4764
4765         case REQ_REFRESH:
4766                 /* Simply reload the view. */
4767                 break;
4768
4769         default:
4770                 return request;
4771         }
4772
4773         open_view(view, REQ_VIEW_STATUS, OPEN_RELOAD);
4774
4775         return REQ_NONE;
4776 }
4777
4778 static void
4779 status_select(struct view *view, struct line *line)
4780 {
4781         struct status *status = line->data;
4782         char file[SIZEOF_STR] = "all files";
4783         const char *text;
4784         const char *key;
4785
4786         if (status && !string_format(file, "'%s'", status->new.name))
4787                 return;
4788
4789         if (!status && line[1].type == LINE_STAT_NONE)
4790                 line++;
4791
4792         switch (line->type) {
4793         case LINE_STAT_STAGED:
4794                 text = "Press %s to unstage %s for commit";
4795                 break;
4796
4797         case LINE_STAT_UNSTAGED:
4798                 text = "Press %s to stage %s for commit";
4799                 break;
4800
4801         case LINE_STAT_UNTRACKED:
4802                 text = "Press %s to stage %s for addition";
4803                 break;
4804
4805         case LINE_STAT_HEAD:
4806         case LINE_STAT_NONE:
4807                 text = "Nothing to update";
4808                 break;
4809
4810         default:
4811                 die("line type %d not handled in switch", line->type);
4812         }
4813
4814         if (status && status->status == 'U') {
4815                 text = "Press %s to resolve conflict in %s";
4816                 key = get_key(REQ_STATUS_MERGE);
4817
4818         } else {
4819                 key = get_key(REQ_STATUS_UPDATE);
4820         }
4821
4822         string_format(view->ref, text, key, file);
4823 }
4824
4825 static bool
4826 status_grep(struct view *view, struct line *line)
4827 {
4828         struct status *status = line->data;
4829         enum { S_STATUS, S_NAME, S_END } state;
4830         char buf[2] = "?";
4831         regmatch_t pmatch;
4832
4833         if (!status)
4834                 return FALSE;
4835
4836         for (state = S_STATUS; state < S_END; state++) {
4837                 const char *text;
4838
4839                 switch (state) {
4840                 case S_NAME:    text = status->new.name;        break;
4841                 case S_STATUS:
4842                         buf[0] = status->status;
4843                         text = buf;
4844                         break;
4845
4846                 default:
4847                         return FALSE;
4848                 }
4849
4850                 if (regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
4851                         return TRUE;
4852         }
4853
4854         return FALSE;
4855 }
4856
4857 static struct view_ops status_ops = {
4858         "file",
4859         NULL,
4860         status_open,
4861         NULL,
4862         status_draw,
4863         status_request,
4864         status_grep,
4865         status_select,
4866 };
4867
4868
4869 static bool
4870 stage_diff_write(struct io *io, struct line *line, struct line *end)
4871 {
4872         while (line < end) {
4873                 if (!io_write(io, line->data, strlen(line->data)) ||
4874                     !io_write(io, "\n", 1))
4875                         return FALSE;
4876                 line++;
4877                 if (line->type == LINE_DIFF_CHUNK ||
4878                     line->type == LINE_DIFF_HEADER)
4879                         break;
4880         }
4881
4882         return TRUE;
4883 }
4884
4885 static struct line *
4886 stage_diff_find(struct view *view, struct line *line, enum line_type type)
4887 {
4888         for (; view->line < line; line--)
4889                 if (line->type == type)
4890                         return line;
4891
4892         return NULL;
4893 }
4894
4895 static bool
4896 stage_apply_chunk(struct view *view, struct line *chunk, bool revert)
4897 {
4898         const char *apply_argv[SIZEOF_ARG] = {
4899                 "git", "apply", "--whitespace=nowarn", NULL
4900         };
4901         struct line *diff_hdr;
4902         struct io io = {};
4903         int argc = 3;
4904
4905         diff_hdr = stage_diff_find(view, chunk, LINE_DIFF_HEADER);
4906         if (!diff_hdr)
4907                 return FALSE;
4908
4909         if (!revert)
4910                 apply_argv[argc++] = "--cached";
4911         if (revert || stage_line_type == LINE_STAT_STAGED)
4912                 apply_argv[argc++] = "-R";
4913         apply_argv[argc++] = "-";
4914         apply_argv[argc++] = NULL;
4915         if (!run_io(&io, apply_argv, opt_cdup, IO_WR))
4916                 return FALSE;
4917
4918         if (!stage_diff_write(&io, diff_hdr, chunk) ||
4919             !stage_diff_write(&io, chunk, view->line + view->lines))
4920                 chunk = NULL;
4921
4922         done_io(&io);
4923         run_io_bg(update_index_argv);
4924
4925         return chunk ? TRUE : FALSE;
4926 }
4927
4928 static bool
4929 stage_update(struct view *view, struct line *line)
4930 {
4931         struct line *chunk = NULL;
4932
4933         if (!is_initial_commit() && stage_line_type != LINE_STAT_UNTRACKED)
4934                 chunk = stage_diff_find(view, line, LINE_DIFF_CHUNK);
4935
4936         if (chunk) {
4937                 if (!stage_apply_chunk(view, chunk, FALSE)) {
4938                         report("Failed to apply chunk");
4939                         return FALSE;
4940                 }
4941
4942         } else if (!stage_status.status) {
4943                 view = VIEW(REQ_VIEW_STATUS);
4944
4945                 for (line = view->line; line < view->line + view->lines; line++)
4946                         if (line->type == stage_line_type)
4947                                 break;
4948
4949                 if (!status_update_files(view, line + 1)) {
4950                         report("Failed to update files");
4951                         return FALSE;
4952                 }
4953
4954         } else if (!status_update_file(&stage_status, stage_line_type)) {
4955                 report("Failed to update file");
4956                 return FALSE;
4957         }
4958
4959         return TRUE;
4960 }
4961
4962 static bool
4963 stage_revert(struct view *view, struct line *line)
4964 {
4965         struct line *chunk = NULL;
4966
4967         if (!is_initial_commit() && stage_line_type == LINE_STAT_UNSTAGED)
4968                 chunk = stage_diff_find(view, line, LINE_DIFF_CHUNK);
4969
4970         if (chunk) {
4971                 if (!prompt_yesno("Are you sure you want to revert changes?"))
4972                         return FALSE;
4973
4974                 if (!stage_apply_chunk(view, chunk, TRUE)) {
4975                         report("Failed to revert chunk");
4976                         return FALSE;
4977                 }
4978                 return TRUE;
4979
4980         } else {
4981                 return status_revert(stage_status.status ? &stage_status : NULL,
4982                                      stage_line_type, FALSE);
4983         }
4984 }
4985
4986
4987 static void
4988 stage_next(struct view *view, struct line *line)
4989 {
4990         int i;
4991
4992         if (!stage_chunks) {
4993                 static size_t alloc = 0;
4994                 int *tmp;
4995
4996                 for (line = view->line; line < view->line + view->lines; line++) {
4997                         if (line->type != LINE_DIFF_CHUNK)
4998                                 continue;
4999
5000                         tmp = realloc_items(stage_chunk, &alloc,
5001                                             stage_chunks, sizeof(*tmp));
5002                         if (!tmp) {
5003                                 report("Allocation failure");
5004                                 return;
5005                         }
5006
5007                         stage_chunk = tmp;
5008                         stage_chunk[stage_chunks++] = line - view->line;
5009                 }
5010         }
5011
5012         for (i = 0; i < stage_chunks; i++) {
5013                 if (stage_chunk[i] > view->lineno) {
5014                         do_scroll_view(view, stage_chunk[i] - view->lineno);
5015                         report("Chunk %d of %d", i + 1, stage_chunks);
5016                         return;
5017                 }
5018         }
5019
5020         report("No next chunk found");
5021 }
5022
5023 static enum request
5024 stage_request(struct view *view, enum request request, struct line *line)
5025 {
5026         switch (request) {
5027         case REQ_STATUS_UPDATE:
5028                 if (!stage_update(view, line))
5029                         return REQ_NONE;
5030                 break;
5031
5032         case REQ_STATUS_REVERT:
5033                 if (!stage_revert(view, line))
5034                         return REQ_NONE;
5035                 break;
5036
5037         case REQ_STAGE_NEXT:
5038                 if (stage_line_type == LINE_STAT_UNTRACKED) {
5039                         report("File is untracked; press %s to add",
5040                                get_key(REQ_STATUS_UPDATE));
5041                         return REQ_NONE;
5042                 }
5043                 stage_next(view, line);
5044                 return REQ_NONE;
5045
5046         case REQ_EDIT:
5047                 if (!stage_status.new.name[0])
5048                         return request;
5049                 if (stage_status.status == 'D') {
5050                         report("File has been deleted.");
5051                         return REQ_NONE;
5052                 }
5053
5054                 open_editor(stage_status.status != '?', stage_status.new.name);
5055                 break;
5056
5057         case REQ_REFRESH:
5058                 /* Reload everything ... */
5059                 break;
5060
5061         case REQ_VIEW_BLAME:
5062                 if (stage_status.new.name[0]) {
5063                         string_copy(opt_file, stage_status.new.name);
5064                         opt_ref[0] = 0;
5065                 }
5066                 return request;
5067
5068         case REQ_ENTER:
5069                 return pager_request(view, request, line);
5070
5071         default:
5072                 return request;
5073         }
5074
5075         open_view(view, REQ_VIEW_STATUS, OPEN_RELOAD | OPEN_NOMAXIMIZE);
5076
5077         /* Check whether the staged entry still exists, and close the
5078          * stage view if it doesn't. */
5079         if (!status_exists(&stage_status, stage_line_type))
5080                 return REQ_VIEW_CLOSE;
5081
5082         if (stage_line_type == LINE_STAT_UNTRACKED) {
5083                 if (!suffixcmp(stage_status.new.name, -1, "/")) {
5084                         report("Cannot display a directory");
5085                         return REQ_NONE;
5086                 }
5087
5088                 if (!prepare_update_file(view, stage_status.new.name)) {
5089                         report("Failed to open file: %s", strerror(errno));
5090                         return REQ_NONE;
5091                 }
5092         }
5093         open_view(view, REQ_VIEW_STAGE, OPEN_REFRESH);
5094
5095         return REQ_NONE;
5096 }
5097
5098 static struct view_ops stage_ops = {
5099         "line",
5100         NULL,
5101         NULL,
5102         pager_read,
5103         pager_draw,
5104         stage_request,
5105         pager_grep,
5106         pager_select,
5107 };
5108
5109
5110 /*
5111  * Revision graph
5112  */
5113
5114 struct commit {
5115         char id[SIZEOF_REV];            /* SHA1 ID. */
5116         char title[128];                /* First line of the commit message. */
5117         char author[75];                /* Author of the commit. */
5118         struct tm time;                 /* Date from the author ident. */
5119         struct ref **refs;              /* Repository references. */
5120         chtype graph[SIZEOF_REVGRAPH];  /* Ancestry chain graphics. */
5121         size_t graph_size;              /* The width of the graph array. */
5122         bool has_parents;               /* Rewritten --parents seen. */
5123 };
5124
5125 /* Size of rev graph with no  "padding" columns */
5126 #define SIZEOF_REVITEMS (SIZEOF_REVGRAPH - (SIZEOF_REVGRAPH / 2))
5127
5128 struct rev_graph {
5129         struct rev_graph *prev, *next, *parents;
5130         char rev[SIZEOF_REVITEMS][SIZEOF_REV];
5131         size_t size;
5132         struct commit *commit;
5133         size_t pos;
5134         unsigned int boundary:1;
5135 };
5136
5137 /* Parents of the commit being visualized. */
5138 static struct rev_graph graph_parents[4];
5139
5140 /* The current stack of revisions on the graph. */
5141 static struct rev_graph graph_stacks[4] = {
5142         { &graph_stacks[3], &graph_stacks[1], &graph_parents[0] },
5143         { &graph_stacks[0], &graph_stacks[2], &graph_parents[1] },
5144         { &graph_stacks[1], &graph_stacks[3], &graph_parents[2] },
5145         { &graph_stacks[2], &graph_stacks[0], &graph_parents[3] },
5146 };
5147
5148 static inline bool
5149 graph_parent_is_merge(struct rev_graph *graph)
5150 {
5151         return graph->parents->size > 1;
5152 }
5153
5154 static inline void
5155 append_to_rev_graph(struct rev_graph *graph, chtype symbol)
5156 {
5157         struct commit *commit = graph->commit;
5158
5159         if (commit->graph_size < ARRAY_SIZE(commit->graph) - 1)
5160                 commit->graph[commit->graph_size++] = symbol;
5161 }
5162
5163 static void
5164 clear_rev_graph(struct rev_graph *graph)
5165 {
5166         graph->boundary = 0;
5167         graph->size = graph->pos = 0;
5168         graph->commit = NULL;
5169         memset(graph->parents, 0, sizeof(*graph->parents));
5170 }
5171
5172 static void
5173 done_rev_graph(struct rev_graph *graph)
5174 {
5175         if (graph_parent_is_merge(graph) &&
5176             graph->pos < graph->size - 1 &&
5177             graph->next->size == graph->size + graph->parents->size - 1) {
5178                 size_t i = graph->pos + graph->parents->size - 1;
5179
5180                 graph->commit->graph_size = i * 2;
5181                 while (i < graph->next->size - 1) {
5182                         append_to_rev_graph(graph, ' ');
5183                         append_to_rev_graph(graph, '\\');
5184                         i++;
5185                 }
5186         }
5187
5188         clear_rev_graph(graph);
5189 }
5190
5191 static void
5192 push_rev_graph(struct rev_graph *graph, const char *parent)
5193 {
5194         int i;
5195
5196         /* "Collapse" duplicate parents lines.
5197          *
5198          * FIXME: This needs to also update update the drawn graph but
5199          * for now it just serves as a method for pruning graph lines. */
5200         for (i = 0; i < graph->size; i++)
5201                 if (!strncmp(graph->rev[i], parent, SIZEOF_REV))
5202                         return;
5203
5204         if (graph->size < SIZEOF_REVITEMS) {
5205                 string_copy_rev(graph->rev[graph->size++], parent);
5206         }
5207 }
5208
5209 static chtype
5210 get_rev_graph_symbol(struct rev_graph *graph)
5211 {
5212         chtype symbol;
5213
5214         if (graph->boundary)
5215                 symbol = REVGRAPH_BOUND;
5216         else if (graph->parents->size == 0)
5217                 symbol = REVGRAPH_INIT;
5218         else if (graph_parent_is_merge(graph))
5219                 symbol = REVGRAPH_MERGE;
5220         else if (graph->pos >= graph->size)
5221                 symbol = REVGRAPH_BRANCH;
5222         else
5223                 symbol = REVGRAPH_COMMIT;
5224
5225         return symbol;
5226 }
5227
5228 static void
5229 draw_rev_graph(struct rev_graph *graph)
5230 {
5231         struct rev_filler {
5232                 chtype separator, line;
5233         };
5234         enum { DEFAULT, RSHARP, RDIAG, LDIAG };
5235         static struct rev_filler fillers[] = {
5236                 { ' ',  '|' },
5237                 { '`',  '.' },
5238                 { '\'', ' ' },
5239                 { '/',  ' ' },
5240         };
5241         chtype symbol = get_rev_graph_symbol(graph);
5242         struct rev_filler *filler;
5243         size_t i;
5244
5245         if (opt_line_graphics)
5246                 fillers[DEFAULT].line = line_graphics[LINE_GRAPHIC_VLINE];
5247
5248         filler = &fillers[DEFAULT];
5249
5250         for (i = 0; i < graph->pos; i++) {
5251                 append_to_rev_graph(graph, filler->line);
5252                 if (graph_parent_is_merge(graph->prev) &&
5253                     graph->prev->pos == i)
5254                         filler = &fillers[RSHARP];
5255
5256                 append_to_rev_graph(graph, filler->separator);
5257         }
5258
5259         /* Place the symbol for this revision. */
5260         append_to_rev_graph(graph, symbol);
5261
5262         if (graph->prev->size > graph->size)
5263                 filler = &fillers[RDIAG];
5264         else
5265                 filler = &fillers[DEFAULT];
5266
5267         i++;
5268
5269         for (; i < graph->size; i++) {
5270                 append_to_rev_graph(graph, filler->separator);
5271                 append_to_rev_graph(graph, filler->line);
5272                 if (graph_parent_is_merge(graph->prev) &&
5273                     i < graph->prev->pos + graph->parents->size)
5274                         filler = &fillers[RSHARP];
5275                 if (graph->prev->size > graph->size)
5276                         filler = &fillers[LDIAG];
5277         }
5278
5279         if (graph->prev->size > graph->size) {
5280                 append_to_rev_graph(graph, filler->separator);
5281                 if (filler->line != ' ')
5282                         append_to_rev_graph(graph, filler->line);
5283         }
5284 }
5285
5286 /* Prepare the next rev graph */
5287 static void
5288 prepare_rev_graph(struct rev_graph *graph)
5289 {
5290         size_t i;
5291
5292         /* First, traverse all lines of revisions up to the active one. */
5293         for (graph->pos = 0; graph->pos < graph->size; graph->pos++) {
5294                 if (!strcmp(graph->rev[graph->pos], graph->commit->id))
5295                         break;
5296
5297                 push_rev_graph(graph->next, graph->rev[graph->pos]);
5298         }
5299
5300         /* Interleave the new revision parent(s). */
5301         for (i = 0; !graph->boundary && i < graph->parents->size; i++)
5302                 push_rev_graph(graph->next, graph->parents->rev[i]);
5303
5304         /* Lastly, put any remaining revisions. */
5305         for (i = graph->pos + 1; i < graph->size; i++)
5306                 push_rev_graph(graph->next, graph->rev[i]);
5307 }
5308
5309 static void
5310 update_rev_graph(struct rev_graph *graph)
5311 {
5312         /* If this is the finalizing update ... */
5313         if (graph->commit)
5314                 prepare_rev_graph(graph);
5315
5316         /* Graph visualization needs a one rev look-ahead,
5317          * so the first update doesn't visualize anything. */
5318         if (!graph->prev->commit)
5319                 return;
5320
5321         draw_rev_graph(graph->prev);
5322         done_rev_graph(graph->prev->prev);
5323 }
5324
5325
5326 /*
5327  * Main view backend
5328  */
5329
5330 static const char *main_argv[SIZEOF_ARG] = {
5331         "git", "log", "--no-color", "--pretty=raw", "--parents",
5332                       "--topo-order", "%(head)", NULL
5333 };
5334
5335 static bool
5336 main_draw(struct view *view, struct line *line, unsigned int lineno)
5337 {
5338         struct commit *commit = line->data;
5339
5340         if (!*commit->author)
5341                 return FALSE;
5342
5343         if (opt_date && draw_date(view, &commit->time))
5344                 return TRUE;
5345
5346         if (opt_author &&
5347             draw_field(view, LINE_MAIN_AUTHOR, commit->author, opt_author_cols, TRUE))
5348                 return TRUE;
5349
5350         if (opt_rev_graph && commit->graph_size &&
5351             draw_graphic(view, LINE_MAIN_REVGRAPH, commit->graph, commit->graph_size))
5352                 return TRUE;
5353
5354         if (opt_show_refs && commit->refs) {
5355                 size_t i = 0;
5356
5357                 do {
5358                         enum line_type type;
5359
5360                         if (commit->refs[i]->head)
5361                                 type = LINE_MAIN_HEAD;
5362                         else if (commit->refs[i]->ltag)
5363                                 type = LINE_MAIN_LOCAL_TAG;
5364                         else if (commit->refs[i]->tag)
5365                                 type = LINE_MAIN_TAG;
5366                         else if (commit->refs[i]->tracked)
5367                                 type = LINE_MAIN_TRACKED;
5368                         else if (commit->refs[i]->remote)
5369                                 type = LINE_MAIN_REMOTE;
5370                         else
5371                                 type = LINE_MAIN_REF;
5372
5373                         if (draw_text(view, type, "[", TRUE) ||
5374                             draw_text(view, type, commit->refs[i]->name, TRUE) ||
5375                             draw_text(view, type, "]", TRUE))
5376                                 return TRUE;
5377
5378                         if (draw_text(view, LINE_DEFAULT, " ", TRUE))
5379                                 return TRUE;
5380                 } while (commit->refs[i++]->next);
5381         }
5382
5383         draw_text(view, LINE_DEFAULT, commit->title, TRUE);
5384         return TRUE;
5385 }
5386
5387 /* Reads git log --pretty=raw output and parses it into the commit struct. */
5388 static bool
5389 main_read(struct view *view, char *line)
5390 {
5391         static struct rev_graph *graph = graph_stacks;
5392         enum line_type type;
5393         struct commit *commit;
5394
5395         if (!line) {
5396                 int i;
5397
5398                 if (!view->lines && !view->parent)
5399                         die("No revisions match the given arguments.");
5400                 if (view->lines > 0) {
5401                         commit = view->line[view->lines - 1].data;
5402                         if (!*commit->author) {
5403                                 view->lines--;
5404                                 free(commit);
5405                                 graph->commit = NULL;
5406                         }
5407                 }
5408                 update_rev_graph(graph);
5409
5410                 for (i = 0; i < ARRAY_SIZE(graph_stacks); i++)
5411                         clear_rev_graph(&graph_stacks[i]);
5412                 return TRUE;
5413         }
5414
5415         type = get_line_type(line);
5416         if (type == LINE_COMMIT) {
5417                 commit = calloc(1, sizeof(struct commit));
5418                 if (!commit)
5419                         return FALSE;
5420
5421                 line += STRING_SIZE("commit ");
5422                 if (*line == '-') {
5423                         graph->boundary = 1;
5424                         line++;
5425                 }
5426
5427                 string_copy_rev(commit->id, line);
5428                 commit->refs = get_refs(commit->id);
5429                 graph->commit = commit;
5430                 add_line_data(view, commit, LINE_MAIN_COMMIT);
5431
5432                 while ((line = strchr(line, ' '))) {
5433                         line++;
5434                         push_rev_graph(graph->parents, line);
5435                         commit->has_parents = TRUE;
5436                 }
5437                 return TRUE;
5438         }
5439
5440         if (!view->lines)
5441                 return TRUE;
5442         commit = view->line[view->lines - 1].data;
5443
5444         switch (type) {
5445         case LINE_PARENT:
5446                 if (commit->has_parents)
5447                         break;
5448                 push_rev_graph(graph->parents, line + STRING_SIZE("parent "));
5449                 break;
5450
5451         case LINE_AUTHOR:
5452         {
5453                 /* Parse author lines where the name may be empty:
5454                  *      author  <email@address.tld> 1138474660 +0100
5455                  */
5456                 char *ident = line + STRING_SIZE("author ");
5457                 char *nameend = strchr(ident, '<');
5458                 char *emailend = strchr(ident, '>');
5459
5460                 if (!nameend || !emailend)
5461                         break;
5462
5463                 update_rev_graph(graph);
5464                 graph = graph->next;
5465
5466                 *nameend = *emailend = 0;
5467                 ident = chomp_string(ident);
5468                 if (!*ident) {
5469                         ident = chomp_string(nameend + 1);
5470                         if (!*ident)
5471                                 ident = "Unknown";
5472                 }
5473
5474                 string_ncopy(commit->author, ident, strlen(ident));
5475
5476                 /* Parse epoch and timezone */
5477                 if (emailend[1] == ' ') {
5478                         char *secs = emailend + 2;
5479                         char *zone = strchr(secs, ' ');
5480                         time_t time = (time_t) atol(secs);
5481
5482                         if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
5483                                 long tz;
5484
5485                                 zone++;
5486                                 tz  = ('0' - zone[1]) * 60 * 60 * 10;
5487                                 tz += ('0' - zone[2]) * 60 * 60;
5488                                 tz += ('0' - zone[3]) * 60;
5489                                 tz += ('0' - zone[4]) * 60;
5490
5491                                 if (zone[0] == '-')
5492                                         tz = -tz;
5493
5494                                 time -= tz;
5495                         }
5496
5497                         gmtime_r(&time, &commit->time);
5498                 }
5499                 break;
5500         }
5501         default:
5502                 /* Fill in the commit title if it has not already been set. */
5503                 if (commit->title[0])
5504                         break;
5505
5506                 /* Require titles to start with a non-space character at the
5507                  * offset used by git log. */
5508                 if (strncmp(line, "    ", 4))
5509                         break;
5510                 line += 4;
5511                 /* Well, if the title starts with a whitespace character,
5512                  * try to be forgiving.  Otherwise we end up with no title. */
5513                 while (isspace(*line))
5514                         line++;
5515                 if (*line == '\0')
5516                         break;
5517                 /* FIXME: More graceful handling of titles; append "..." to
5518                  * shortened titles, etc. */
5519
5520                 string_ncopy(commit->title, line, strlen(line));
5521         }
5522
5523         return TRUE;
5524 }
5525
5526 static enum request
5527 main_request(struct view *view, enum request request, struct line *line)
5528 {
5529         enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
5530
5531         switch (request) {
5532         case REQ_ENTER:
5533                 open_view(view, REQ_VIEW_DIFF, flags);
5534                 break;
5535         case REQ_REFRESH:
5536                 load_refs();
5537                 open_view(view, REQ_VIEW_MAIN, OPEN_REFRESH);
5538                 break;
5539         default:
5540                 return request;
5541         }
5542
5543         return REQ_NONE;
5544 }
5545
5546 static bool
5547 grep_refs(struct ref **refs, regex_t *regex)
5548 {
5549         regmatch_t pmatch;
5550         size_t i = 0;
5551
5552         if (!refs)
5553                 return FALSE;
5554         do {
5555                 if (regexec(regex, refs[i]->name, 1, &pmatch, 0) != REG_NOMATCH)
5556                         return TRUE;
5557         } while (refs[i++]->next);
5558
5559         return FALSE;
5560 }
5561
5562 static bool
5563 main_grep(struct view *view, struct line *line)
5564 {
5565         struct commit *commit = line->data;
5566         enum { S_TITLE, S_AUTHOR, S_DATE, S_REFS, S_END } state;
5567         char buf[DATE_COLS + 1];
5568         regmatch_t pmatch;
5569
5570         for (state = S_TITLE; state < S_END; state++) {
5571                 char *text;
5572
5573                 switch (state) {
5574                 case S_TITLE:   text = commit->title;   break;
5575                 case S_AUTHOR:
5576                         if (!opt_author)
5577                                 continue;
5578                         text = commit->author;
5579                         break;
5580                 case S_DATE:
5581                         if (!opt_date)
5582                                 continue;
5583                         if (!strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time))
5584                                 continue;
5585                         text = buf;
5586                         break;
5587                 case S_REFS:
5588                         if (!opt_show_refs)
5589                                 continue;
5590                         if (grep_refs(commit->refs, view->regex) == TRUE)
5591                                 return TRUE;
5592                         continue;
5593                 default:
5594                         return FALSE;
5595                 }
5596
5597                 if (regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
5598                         return TRUE;
5599         }
5600
5601         return FALSE;
5602 }
5603
5604 static void
5605 main_select(struct view *view, struct line *line)
5606 {
5607         struct commit *commit = line->data;
5608
5609         string_copy_rev(view->ref, commit->id);
5610         string_copy_rev(ref_commit, view->ref);
5611 }
5612
5613 static struct view_ops main_ops = {
5614         "commit",
5615         main_argv,
5616         NULL,
5617         main_read,
5618         main_draw,
5619         main_request,
5620         main_grep,
5621         main_select,
5622 };
5623
5624
5625 /*
5626  * Unicode / UTF-8 handling
5627  *
5628  * NOTE: Much of the following code for dealing with unicode is derived from
5629  * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
5630  * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
5631  */
5632
5633 /* I've (over)annotated a lot of code snippets because I am not entirely
5634  * confident that the approach taken by this small UTF-8 interface is correct.
5635  * --jonas */
5636
5637 static inline int
5638 unicode_width(unsigned long c)
5639 {
5640         if (c >= 0x1100 &&
5641            (c <= 0x115f                         /* Hangul Jamo */
5642             || c == 0x2329
5643             || c == 0x232a
5644             || (c >= 0x2e80  && c <= 0xa4cf && c != 0x303f)
5645                                                 /* CJK ... Yi */
5646             || (c >= 0xac00  && c <= 0xd7a3)    /* Hangul Syllables */
5647             || (c >= 0xf900  && c <= 0xfaff)    /* CJK Compatibility Ideographs */
5648             || (c >= 0xfe30  && c <= 0xfe6f)    /* CJK Compatibility Forms */
5649             || (c >= 0xff00  && c <= 0xff60)    /* Fullwidth Forms */
5650             || (c >= 0xffe0  && c <= 0xffe6)
5651             || (c >= 0x20000 && c <= 0x2fffd)
5652             || (c >= 0x30000 && c <= 0x3fffd)))
5653                 return 2;
5654
5655         if (c == '\t')
5656                 return opt_tab_size;
5657
5658         return 1;
5659 }
5660
5661 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
5662  * Illegal bytes are set one. */
5663 static const unsigned char utf8_bytes[256] = {
5664         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,
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         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,
5671         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,
5672 };
5673
5674 /* Decode UTF-8 multi-byte representation into a unicode character. */
5675 static inline unsigned long
5676 utf8_to_unicode(const char *string, size_t length)
5677 {
5678         unsigned long unicode;
5679
5680         switch (length) {
5681         case 1:
5682                 unicode  =   string[0];
5683                 break;
5684         case 2:
5685                 unicode  =  (string[0] & 0x1f) << 6;
5686                 unicode +=  (string[1] & 0x3f);
5687                 break;
5688         case 3:
5689                 unicode  =  (string[0] & 0x0f) << 12;
5690                 unicode += ((string[1] & 0x3f) << 6);
5691                 unicode +=  (string[2] & 0x3f);
5692                 break;
5693         case 4:
5694                 unicode  =  (string[0] & 0x0f) << 18;
5695                 unicode += ((string[1] & 0x3f) << 12);
5696                 unicode += ((string[2] & 0x3f) << 6);
5697                 unicode +=  (string[3] & 0x3f);
5698                 break;
5699         case 5:
5700                 unicode  =  (string[0] & 0x0f) << 24;
5701                 unicode += ((string[1] & 0x3f) << 18);
5702                 unicode += ((string[2] & 0x3f) << 12);
5703                 unicode += ((string[3] & 0x3f) << 6);
5704                 unicode +=  (string[4] & 0x3f);
5705                 break;
5706         case 6:
5707                 unicode  =  (string[0] & 0x01) << 30;
5708                 unicode += ((string[1] & 0x3f) << 24);
5709                 unicode += ((string[2] & 0x3f) << 18);
5710                 unicode += ((string[3] & 0x3f) << 12);
5711                 unicode += ((string[4] & 0x3f) << 6);
5712                 unicode +=  (string[5] & 0x3f);
5713                 break;
5714         default:
5715                 die("Invalid unicode length");
5716         }
5717
5718         /* Invalid characters could return the special 0xfffd value but NUL
5719          * should be just as good. */
5720         return unicode > 0xffff ? 0 : unicode;
5721 }
5722
5723 /* Calculates how much of string can be shown within the given maximum width
5724  * and sets trimmed parameter to non-zero value if all of string could not be
5725  * shown. If the reserve flag is TRUE, it will reserve at least one
5726  * trailing character, which can be useful when drawing a delimiter.
5727  *
5728  * Returns the number of bytes to output from string to satisfy max_width. */
5729 static size_t
5730 utf8_length(const char *string, int *width, size_t max_width, int *trimmed, bool reserve)
5731 {
5732         const char *start = string;
5733         const char *end = strchr(string, '\0');
5734         unsigned char last_bytes = 0;
5735         size_t last_ucwidth = 0;
5736
5737         *width = 0;
5738         *trimmed = 0;
5739
5740         while (string < end) {
5741                 int c = *(unsigned char *) string;
5742                 unsigned char bytes = utf8_bytes[c];
5743                 size_t ucwidth;
5744                 unsigned long unicode;
5745
5746                 if (string + bytes > end)
5747                         break;
5748
5749                 /* Change representation to figure out whether
5750                  * it is a single- or double-width character. */
5751
5752                 unicode = utf8_to_unicode(string, bytes);
5753                 /* FIXME: Graceful handling of invalid unicode character. */
5754                 if (!unicode)
5755                         break;
5756
5757                 ucwidth = unicode_width(unicode);
5758                 *width  += ucwidth;
5759                 if (*width > max_width) {
5760                         *trimmed = 1;
5761                         *width -= ucwidth;
5762                         if (reserve && *width == max_width) {
5763                                 string -= last_bytes;
5764                                 *width -= last_ucwidth;
5765                         }
5766                         break;
5767                 }
5768
5769                 string  += bytes;
5770                 last_bytes = bytes;
5771                 last_ucwidth = ucwidth;
5772         }
5773
5774         return string - start;
5775 }
5776
5777
5778 /*
5779  * Status management
5780  */
5781
5782 /* Whether or not the curses interface has been initialized. */
5783 static bool cursed = FALSE;
5784
5785 /* The status window is used for polling keystrokes. */
5786 static WINDOW *status_win;
5787
5788 static bool status_empty = TRUE;
5789
5790 /* Update status and title window. */
5791 static void
5792 report(const char *msg, ...)
5793 {
5794         struct view *view = display[current_view];
5795
5796         if (input_mode)
5797                 return;
5798
5799         if (!view) {
5800                 char buf[SIZEOF_STR];
5801                 va_list args;
5802
5803                 va_start(args, msg);
5804                 if (vsnprintf(buf, sizeof(buf), msg, args) >= sizeof(buf)) {
5805                         buf[sizeof(buf) - 1] = 0;
5806                         buf[sizeof(buf) - 2] = '.';
5807                         buf[sizeof(buf) - 3] = '.';
5808                         buf[sizeof(buf) - 4] = '.';
5809                 }
5810                 va_end(args);
5811                 die("%s", buf);
5812         }
5813
5814         if (!status_empty || *msg) {
5815                 va_list args;
5816
5817                 va_start(args, msg);
5818
5819                 wmove(status_win, 0, 0);
5820                 if (*msg) {
5821                         vwprintw(status_win, msg, args);
5822                         status_empty = FALSE;
5823                 } else {
5824                         status_empty = TRUE;
5825                 }
5826                 wclrtoeol(status_win);
5827                 wrefresh(status_win);
5828
5829                 va_end(args);
5830         }
5831
5832         update_view_title(view);
5833         update_display_cursor(view);
5834 }
5835
5836 /* Controls when nodelay should be in effect when polling user input. */
5837 static void
5838 set_nonblocking_input(bool loading)
5839 {
5840         static unsigned int loading_views;
5841
5842         if ((loading == FALSE && loading_views-- == 1) ||
5843             (loading == TRUE  && loading_views++ == 0))
5844                 nodelay(status_win, loading);
5845 }
5846
5847 static void
5848 init_display(void)
5849 {
5850         int x, y;
5851
5852         /* Initialize the curses library */
5853         if (isatty(STDIN_FILENO)) {
5854                 cursed = !!initscr();
5855                 opt_tty = stdin;
5856         } else {
5857                 /* Leave stdin and stdout alone when acting as a pager. */
5858                 opt_tty = fopen("/dev/tty", "r+");
5859                 if (!opt_tty)
5860                         die("Failed to open /dev/tty");
5861                 cursed = !!newterm(NULL, opt_tty, opt_tty);
5862         }
5863
5864         if (!cursed)
5865                 die("Failed to initialize curses");
5866
5867         nonl();         /* Tell curses not to do NL->CR/NL on output */
5868         cbreak();       /* Take input chars one at a time, no wait for \n */
5869         noecho();       /* Don't echo input */
5870         leaveok(stdscr, TRUE);
5871
5872         if (has_colors())
5873                 init_colors();
5874
5875         getmaxyx(stdscr, y, x);
5876         status_win = newwin(1, 0, y - 1, 0);
5877         if (!status_win)
5878                 die("Failed to create status window");
5879
5880         /* Enable keyboard mapping */
5881         keypad(status_win, TRUE);
5882         wbkgdset(status_win, get_line_attr(LINE_STATUS));
5883
5884         TABSIZE = opt_tab_size;
5885         if (opt_line_graphics) {
5886                 line_graphics[LINE_GRAPHIC_VLINE] = ACS_VLINE;
5887         }
5888 }
5889
5890 static bool
5891 prompt_yesno(const char *prompt)
5892 {
5893         enum { WAIT, STOP, CANCEL  } status = WAIT;
5894         bool answer = FALSE;
5895
5896         while (status == WAIT) {
5897                 struct view *view;
5898                 int i, key;
5899
5900                 input_mode = TRUE;
5901
5902                 foreach_view (view, i)
5903                         update_view(view);
5904
5905                 input_mode = FALSE;
5906
5907                 mvwprintw(status_win, 0, 0, "%s [Yy]/[Nn]", prompt);
5908                 wclrtoeol(status_win);
5909
5910                 /* Refresh, accept single keystroke of input */
5911                 key = wgetch(status_win);
5912                 switch (key) {
5913                 case ERR:
5914                         break;
5915
5916                 case 'y':
5917                 case 'Y':
5918                         answer = TRUE;
5919                         status = STOP;
5920                         break;
5921
5922                 case KEY_ESC:
5923                 case KEY_RETURN:
5924                 case KEY_ENTER:
5925                 case KEY_BACKSPACE:
5926                 case 'n':
5927                 case 'N':
5928                 case '\n':
5929                 default:
5930                         answer = FALSE;
5931                         status = CANCEL;
5932                 }
5933         }
5934
5935         /* Clear the status window */
5936         status_empty = FALSE;
5937         report("");
5938
5939         return answer;
5940 }
5941
5942 static char *
5943 read_prompt(const char *prompt)
5944 {
5945         enum { READING, STOP, CANCEL } status = READING;
5946         static char buf[SIZEOF_STR];
5947         int pos = 0;
5948
5949         while (status == READING) {
5950                 struct view *view;
5951                 int i, key;
5952
5953                 input_mode = TRUE;
5954
5955                 foreach_view (view, i)
5956                         update_view(view);
5957
5958                 input_mode = FALSE;
5959
5960                 mvwprintw(status_win, 0, 0, "%s%.*s", prompt, pos, buf);
5961                 wclrtoeol(status_win);
5962
5963                 /* Refresh, accept single keystroke of input */
5964                 key = wgetch(status_win);
5965                 switch (key) {
5966                 case KEY_RETURN:
5967                 case KEY_ENTER:
5968                 case '\n':
5969                         status = pos ? STOP : CANCEL;
5970                         break;
5971
5972                 case KEY_BACKSPACE:
5973                         if (pos > 0)
5974                                 pos--;
5975                         else
5976                                 status = CANCEL;
5977                         break;
5978
5979                 case KEY_ESC:
5980                         status = CANCEL;
5981                         break;
5982
5983                 case ERR:
5984                         break;
5985
5986                 default:
5987                         if (pos >= sizeof(buf)) {
5988                                 report("Input string too long");
5989                                 return NULL;
5990                         }
5991
5992                         if (isprint(key))
5993                                 buf[pos++] = (char) key;
5994                 }
5995         }
5996
5997         /* Clear the status window */
5998         status_empty = FALSE;
5999         report("");
6000
6001         if (status == CANCEL)
6002                 return NULL;
6003
6004         buf[pos++] = 0;
6005
6006         return buf;
6007 }
6008
6009 /*
6010  * Repository properties
6011  */
6012
6013 static int
6014 git_properties(const char **argv, const char *separators,
6015                int (*read_property)(char *, size_t, char *, size_t))
6016 {
6017         struct io io = {};
6018
6019         if (init_io_rd(&io, argv, NULL, FORMAT_NONE))
6020                 return read_properties(&io, separators, read_property);
6021         return ERR;
6022 }
6023
6024 static struct ref *refs = NULL;
6025 static size_t refs_alloc = 0;
6026 static size_t refs_size = 0;
6027
6028 /* Id <-> ref store */
6029 static struct ref ***id_refs = NULL;
6030 static size_t id_refs_alloc = 0;
6031 static size_t id_refs_size = 0;
6032
6033 static int
6034 compare_refs(const void *ref1_, const void *ref2_)
6035 {
6036         const struct ref *ref1 = *(const struct ref **)ref1_;
6037         const struct ref *ref2 = *(const struct ref **)ref2_;
6038
6039         if (ref1->tag != ref2->tag)
6040                 return ref2->tag - ref1->tag;
6041         if (ref1->ltag != ref2->ltag)
6042                 return ref2->ltag - ref2->ltag;
6043         if (ref1->head != ref2->head)
6044                 return ref2->head - ref1->head;
6045         if (ref1->tracked != ref2->tracked)
6046                 return ref2->tracked - ref1->tracked;
6047         if (ref1->remote != ref2->remote)
6048                 return ref2->remote - ref1->remote;
6049         return strcmp(ref1->name, ref2->name);
6050 }
6051
6052 static struct ref **
6053 get_refs(const char *id)
6054 {
6055         struct ref ***tmp_id_refs;
6056         struct ref **ref_list = NULL;
6057         size_t ref_list_alloc = 0;
6058         size_t ref_list_size = 0;
6059         size_t i;
6060
6061         for (i = 0; i < id_refs_size; i++)
6062                 if (!strcmp(id, id_refs[i][0]->id))
6063                         return id_refs[i];
6064
6065         tmp_id_refs = realloc_items(id_refs, &id_refs_alloc, id_refs_size + 1,
6066                                     sizeof(*id_refs));
6067         if (!tmp_id_refs)
6068                 return NULL;
6069
6070         id_refs = tmp_id_refs;
6071
6072         for (i = 0; i < refs_size; i++) {
6073                 struct ref **tmp;
6074
6075                 if (strcmp(id, refs[i].id))
6076                         continue;
6077
6078                 tmp = realloc_items(ref_list, &ref_list_alloc,
6079                                     ref_list_size + 1, sizeof(*ref_list));
6080                 if (!tmp) {
6081                         if (ref_list)
6082                                 free(ref_list);
6083                         return NULL;
6084                 }
6085
6086                 ref_list = tmp;
6087                 ref_list[ref_list_size] = &refs[i];
6088                 /* XXX: The properties of the commit chains ensures that we can
6089                  * safely modify the shared ref. The repo references will
6090                  * always be similar for the same id. */
6091                 ref_list[ref_list_size]->next = 1;
6092
6093                 ref_list_size++;
6094         }
6095
6096         if (ref_list) {
6097                 qsort(ref_list, ref_list_size, sizeof(*ref_list), compare_refs);
6098                 ref_list[ref_list_size - 1]->next = 0;
6099                 id_refs[id_refs_size++] = ref_list;
6100         }
6101
6102         return ref_list;
6103 }
6104
6105 static int
6106 read_ref(char *id, size_t idlen, char *name, size_t namelen)
6107 {
6108         struct ref *ref;
6109         bool tag = FALSE;
6110         bool ltag = FALSE;
6111         bool remote = FALSE;
6112         bool tracked = FALSE;
6113         bool check_replace = FALSE;
6114         bool head = FALSE;
6115
6116         if (!prefixcmp(name, "refs/tags/")) {
6117                 if (!suffixcmp(name, namelen, "^{}")) {
6118                         namelen -= 3;
6119                         name[namelen] = 0;
6120                         if (refs_size > 0 && refs[refs_size - 1].ltag == TRUE)
6121                                 check_replace = TRUE;
6122                 } else {
6123                         ltag = TRUE;
6124                 }
6125
6126                 tag = TRUE;
6127                 namelen -= STRING_SIZE("refs/tags/");
6128                 name    += STRING_SIZE("refs/tags/");
6129
6130         } else if (!prefixcmp(name, "refs/remotes/")) {
6131                 remote = TRUE;
6132                 namelen -= STRING_SIZE("refs/remotes/");
6133                 name    += STRING_SIZE("refs/remotes/");
6134                 tracked  = !strcmp(opt_remote, name);
6135
6136         } else if (!prefixcmp(name, "refs/heads/")) {
6137                 namelen -= STRING_SIZE("refs/heads/");
6138                 name    += STRING_SIZE("refs/heads/");
6139                 head     = !strncmp(opt_head, name, namelen);
6140
6141         } else if (!strcmp(name, "HEAD")) {
6142                 string_ncopy(opt_head_rev, id, idlen);
6143                 return OK;
6144         }
6145
6146         if (check_replace && !strcmp(name, refs[refs_size - 1].name)) {
6147                 /* it's an annotated tag, replace the previous sha1 with the
6148                  * resolved commit id; relies on the fact git-ls-remote lists
6149                  * the commit id of an annotated tag right before the commit id
6150                  * it points to. */
6151                 refs[refs_size - 1].ltag = ltag;
6152                 string_copy_rev(refs[refs_size - 1].id, id);
6153
6154                 return OK;
6155         }
6156         refs = realloc_items(refs, &refs_alloc, refs_size + 1, sizeof(*refs));
6157         if (!refs)
6158                 return ERR;
6159
6160         ref = &refs[refs_size++];
6161         ref->name = malloc(namelen + 1);
6162         if (!ref->name)
6163                 return ERR;
6164
6165         strncpy(ref->name, name, namelen);
6166         ref->name[namelen] = 0;
6167         ref->head = head;
6168         ref->tag = tag;
6169         ref->ltag = ltag;
6170         ref->remote = remote;
6171         ref->tracked = tracked;
6172         string_copy_rev(ref->id, id);
6173
6174         return OK;
6175 }
6176
6177 static int
6178 load_refs(void)
6179 {
6180         static const char *ls_remote_argv[SIZEOF_ARG] = {
6181                 "git", "ls-remote", ".", NULL
6182         };
6183         static bool init = FALSE;
6184
6185         if (!init) {
6186                 argv_from_env(ls_remote_argv, "TIG_LS_REMOTE");
6187                 init = TRUE;
6188         }
6189
6190         if (!*opt_git_dir)
6191                 return OK;
6192
6193         while (refs_size > 0)
6194                 free(refs[--refs_size].name);
6195         while (id_refs_size > 0)
6196                 free(id_refs[--id_refs_size]);
6197
6198         return git_properties(ls_remote_argv, "\t", read_ref);
6199 }
6200
6201 static int
6202 read_repo_config_option(char *name, size_t namelen, char *value, size_t valuelen)
6203 {
6204         if (!strcmp(name, "i18n.commitencoding"))
6205                 string_ncopy(opt_encoding, value, valuelen);
6206
6207         if (!strcmp(name, "core.editor"))
6208                 string_ncopy(opt_editor, value, valuelen);
6209
6210         /* branch.<head>.remote */
6211         if (*opt_head &&
6212             !strncmp(name, "branch.", 7) &&
6213             !strncmp(name + 7, opt_head, strlen(opt_head)) &&
6214             !strcmp(name + 7 + strlen(opt_head), ".remote"))
6215                 string_ncopy(opt_remote, value, valuelen);
6216
6217         if (*opt_head && *opt_remote &&
6218             !strncmp(name, "branch.", 7) &&
6219             !strncmp(name + 7, opt_head, strlen(opt_head)) &&
6220             !strcmp(name + 7 + strlen(opt_head), ".merge")) {
6221                 size_t from = strlen(opt_remote);
6222
6223                 if (!prefixcmp(value, "refs/heads/")) {
6224                         value += STRING_SIZE("refs/heads/");
6225                         valuelen -= STRING_SIZE("refs/heads/");
6226                 }
6227
6228                 if (!string_format_from(opt_remote, &from, "/%s", value))
6229                         opt_remote[0] = 0;
6230         }
6231
6232         return OK;
6233 }
6234
6235 static int
6236 load_git_config(void)
6237 {
6238         const char *config_list_argv[] = { "git", GIT_CONFIG, "--list", NULL };
6239
6240         return git_properties(config_list_argv, "=", read_repo_config_option);
6241 }
6242
6243 static int
6244 read_repo_info(char *name, size_t namelen, char *value, size_t valuelen)
6245 {
6246         if (!opt_git_dir[0]) {
6247                 string_ncopy(opt_git_dir, name, namelen);
6248
6249         } else if (opt_is_inside_work_tree == -1) {
6250                 /* This can be 3 different values depending on the
6251                  * version of git being used. If git-rev-parse does not
6252                  * understand --is-inside-work-tree it will simply echo
6253                  * the option else either "true" or "false" is printed.
6254                  * Default to true for the unknown case. */
6255                 opt_is_inside_work_tree = strcmp(name, "false") ? TRUE : FALSE;
6256         } else {
6257                 string_ncopy(opt_cdup, name, namelen);
6258         }
6259
6260         return OK;
6261 }
6262
6263 static int
6264 load_repo_info(void)
6265 {
6266         const char *head_argv[] = {
6267                 "git", "symbolic-ref", "HEAD", NULL
6268         };
6269         const char *rev_parse_argv[] = {
6270                 "git", "rev-parse", "--git-dir", "--is-inside-work-tree",
6271                         "--show-cdup", NULL
6272         };
6273
6274         if (run_io_buf(head_argv, opt_head, sizeof(opt_head))) {
6275                 chomp_string(opt_head);
6276                 if (!prefixcmp(opt_head, "refs/heads/")) {
6277                         char *offset = opt_head + STRING_SIZE("refs/heads/");
6278
6279                         memmove(opt_head, offset, strlen(offset) + 1);
6280                 }
6281         }
6282
6283         return git_properties(rev_parse_argv, "=", read_repo_info);
6284 }
6285
6286 static int
6287 read_properties(struct io *io, const char *separators,
6288                 int (*read_property)(char *, size_t, char *, size_t))
6289 {
6290         char *name;
6291         int state = OK;
6292
6293         if (!start_io(io))
6294                 return ERR;
6295
6296         while (state == OK && (name = io_get(io, '\n', TRUE))) {
6297                 char *value;
6298                 size_t namelen;
6299                 size_t valuelen;
6300
6301                 name = chomp_string(name);
6302                 namelen = strcspn(name, separators);
6303
6304                 if (name[namelen]) {
6305                         name[namelen] = 0;
6306                         value = chomp_string(name + namelen + 1);
6307                         valuelen = strlen(value);
6308
6309                 } else {
6310                         value = "";
6311                         valuelen = 0;
6312                 }
6313
6314                 state = read_property(name, namelen, value, valuelen);
6315         }
6316
6317         if (state != ERR && io_error(io))
6318                 state = ERR;
6319         done_io(io);
6320
6321         return state;
6322 }
6323
6324
6325 /*
6326  * Main
6327  */
6328
6329 static void __NORETURN
6330 quit(int sig)
6331 {
6332         /* XXX: Restore tty modes and let the OS cleanup the rest! */
6333         if (cursed)
6334                 endwin();
6335         exit(0);
6336 }
6337
6338 static void __NORETURN
6339 die(const char *err, ...)
6340 {
6341         va_list args;
6342
6343         endwin();
6344
6345         va_start(args, err);
6346         fputs("tig: ", stderr);
6347         vfprintf(stderr, err, args);
6348         fputs("\n", stderr);
6349         va_end(args);
6350
6351         exit(1);
6352 }
6353
6354 static void
6355 warn(const char *msg, ...)
6356 {
6357         va_list args;
6358
6359         va_start(args, msg);
6360         fputs("tig warning: ", stderr);
6361         vfprintf(stderr, msg, args);
6362         fputs("\n", stderr);
6363         va_end(args);
6364 }
6365
6366 int
6367 main(int argc, const char *argv[])
6368 {
6369         const char **run_argv = NULL;
6370         struct view *view;
6371         enum request request;
6372         size_t i;
6373
6374         signal(SIGINT, quit);
6375
6376         if (setlocale(LC_ALL, "")) {
6377                 char *codeset = nl_langinfo(CODESET);
6378
6379                 string_ncopy(opt_codeset, codeset, strlen(codeset));
6380         }
6381
6382         if (load_repo_info() == ERR)
6383                 die("Failed to load repo info.");
6384
6385         if (load_options() == ERR)
6386                 die("Failed to load user config.");
6387
6388         if (load_git_config() == ERR)
6389                 die("Failed to load repo config.");
6390
6391         request = parse_options(argc, argv, &run_argv);
6392         if (request == REQ_NONE)
6393                 return 0;
6394
6395         /* Require a git repository unless when running in pager mode. */
6396         if (!opt_git_dir[0] && request != REQ_VIEW_PAGER)
6397                 die("Not a git repository");
6398
6399         if (*opt_encoding && strcasecmp(opt_encoding, "UTF-8"))
6400                 opt_utf8 = FALSE;
6401
6402         if (*opt_codeset && strcmp(opt_codeset, opt_encoding)) {
6403                 opt_iconv = iconv_open(opt_codeset, opt_encoding);
6404                 if (opt_iconv == ICONV_NONE)
6405                         die("Failed to initialize character set conversion");
6406         }
6407
6408         if (load_refs() == ERR)
6409                 die("Failed to load refs.");
6410
6411         foreach_view (view, i)
6412                 argv_from_env(view->ops->argv, view->cmd_env);
6413
6414         init_display();
6415
6416         if (request == REQ_VIEW_PAGER || run_argv) {
6417                 if (request == REQ_VIEW_PAGER)
6418                         io_open(&VIEW(request)->io, "");
6419                 else if (!prepare_update(VIEW(request), run_argv, NULL, FORMAT_NONE))
6420                         die("Failed to format arguments");
6421                 open_view(NULL, request, OPEN_PREPARED);
6422                 request = REQ_NONE;
6423         }
6424
6425         while (view_driver(display[current_view], request)) {
6426                 int key;
6427                 int i;
6428
6429                 foreach_view (view, i)
6430                         update_view(view);
6431                 view = display[current_view];
6432
6433                 /* Refresh, accept single keystroke of input */
6434                 key = wgetch(status_win);
6435
6436                 /* wgetch() with nodelay() enabled returns ERR when there's no
6437                  * input. */
6438                 if (key == ERR) {
6439                         request = REQ_NONE;
6440                         continue;
6441                 }
6442
6443                 request = get_keybinding(view->keymap, key);
6444
6445                 /* Some low-level request handling. This keeps access to
6446                  * status_win restricted. */
6447                 switch (request) {
6448                 case REQ_PROMPT:
6449                 {
6450                         char *cmd = read_prompt(":");
6451
6452                         if (cmd) {
6453                                 struct view *next = VIEW(REQ_VIEW_PAGER);
6454                                 const char *argv[SIZEOF_ARG] = { "git" };
6455                                 int argc = 1;
6456
6457                                 /* When running random commands, initially show the
6458                                  * command in the title. However, it maybe later be
6459                                  * overwritten if a commit line is selected. */
6460                                 string_ncopy(next->ref, cmd, strlen(cmd));
6461
6462                                 if (!argv_from_string(argv, &argc, cmd)) {
6463                                         report("Too many arguments");
6464                                 } else if (!prepare_update(next, argv, NULL, FORMAT_DASH)) {
6465                                         report("Failed to format command");
6466                                 } else {
6467                                         open_view(view, REQ_VIEW_PAGER, OPEN_PREPARED);
6468                                 }
6469                         }
6470
6471                         request = REQ_NONE;
6472                         break;
6473                 }
6474                 case REQ_SEARCH:
6475                 case REQ_SEARCH_BACK:
6476                 {
6477                         const char *prompt = request == REQ_SEARCH ? "/" : "?";
6478                         char *search = read_prompt(prompt);
6479
6480                         if (search)
6481                                 string_ncopy(opt_search, search, strlen(search));
6482                         else
6483                                 request = REQ_NONE;
6484                         break;
6485                 }
6486                 case REQ_SCREEN_RESIZE:
6487                 {
6488                         int height, width;
6489
6490                         getmaxyx(stdscr, height, width);
6491
6492                         /* Resize the status view and let the view driver take
6493                          * care of resizing the displayed views. */
6494                         wresize(status_win, 1, width);
6495                         mvwin(status_win, height - 1, 0);
6496                         wrefresh(status_win);
6497                         break;
6498                 }
6499                 default:
6500                         break;
6501                 }
6502         }
6503
6504         quit(0);
6505
6506         return 0;
6507 }