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