chiark - git - mdw - tig/blob - tig.c

   1 /* Copyright (c) 2006 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  * TIG(1)
  15  * ======
  16  *
  17  * NAME
  18  * ----
  19  * tig - text-mode interface for git
  20  *
  21  * SYNOPSIS
  22  * --------
  23  * [verse]
  24  * tig [options]
  25  * tig [options] [--] [git log options]
  26  * tig [options] log  [git log options]
  27  * tig [options] diff [git diff options]
  28  * tig [options] show [git show options]
  29  * tig [options] <    [git command output]
  30  *
  31  * DESCRIPTION
  32  * -----------
  33  * Browse changes in a git repository. Additionally, tig(1) can also act
  34  * as a pager for output of various git commands.
  35  *
  36  * When browsing repositories, tig(1) uses the underlying git commands
  37  * to present the user with various views, such as summarized commit log
  38  * and showing the commit with the log message, diffstat, and the diff.
  39  *
  40  * Using tig(1) as a pager, it will display input from stdin and try
  41  * to colorize it.
  42  **/
  43
  44 #ifndef VERSION
  45 #define VERSION "tig-0.3"
  46 #endif
  47
  48 #ifndef DEBUG
  49 #define NDEBUG
  50 #endif
  51
  52 #include <assert.h>
  53 #include <errno.h>
  54 #include <ctype.h>
  55 #include <signal.h>
  56 #include <stdarg.h>
  57 #include <stdio.h>
  58 #include <stdlib.h>
  59 #include <string.h>
  60 #include <unistd.h>
  61 #include <time.h>
  62
  63 #include <curses.h>
  64
  65 static void die(const char *err, ...);
  66 static void report(const char *msg, ...);
  67 static int read_properties(FILE *pipe, const char *separators, int (*read)(char *, int, char *, int));
  68 static void set_nonblocking_input(bool loading);
  69 static size_t utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed);
  70
  71 #define ABS(x)          ((x) >= 0  ? (x) : -(x))
  72 #define MIN(x, y)       ((x) < (y) ? (x) :  (y))
  73
  74 #define ARRAY_SIZE(x)   (sizeof(x) / sizeof(x[0]))
  75 #define STRING_SIZE(x)  (sizeof(x) - 1)
  76
  77 #define SIZEOF_REF      256     /* Size of symbolic or SHA1 ID. */
  78 #define SIZEOF_CMD      1024    /* Size of command buffer. */
  79
  80 /* This color name can be used to refer to the default term colors. */
  81 #define COLOR_DEFAULT   (-1)
  82
  83 #define TIG_HELP        "(d)iff, (l)og, (m)ain, (q)uit, (h)elp"
  84
  85 /* The format and size of the date column in the main view. */
  86 #define DATE_FORMAT     "%Y-%m-%d %H:%M"
  87 #define DATE_COLS       STRING_SIZE("2006-04-29 14:21 ")
  88
  89 #define AUTHOR_COLS     20
  90
  91 /* The default interval between line numbers. */
  92 #define NUMBER_INTERVAL 1
  93
  94 #define TABSIZE         8
  95
  96 #define SCALE_SPLIT_VIEW(height)        ((height) * 2 / 3)
  97
  98 /* Some ascii-shorthands fitted into the ncurses namespace. */
  99 #define KEY_TAB         '\t'
 100 #define KEY_RETURN      '\r'
 101 #define KEY_ESC         27
 102
 103
 104 /* User action requests. */
 105 enum request {
 106         /* Offset all requests to avoid conflicts with ncurses getch values. */
 107         REQ_OFFSET = KEY_MAX + 1,
 108
 109         /* XXX: Keep the view request first and in sync with views[]. */
 110         REQ_VIEW_MAIN,
 111         REQ_VIEW_DIFF,
 112         REQ_VIEW_LOG,
 113         REQ_VIEW_HELP,
 114         REQ_VIEW_PAGER,
 115
 116         REQ_ENTER,
 117         REQ_QUIT,
 118         REQ_PROMPT,
 119         REQ_SCREEN_REDRAW,
 120         REQ_SCREEN_RESIZE,
 121         REQ_SCREEN_UPDATE,
 122         REQ_SHOW_VERSION,
 123         REQ_STOP_LOADING,
 124         REQ_TOGGLE_LINE_NUMBERS,
 125         REQ_VIEW_NEXT,
 126         REQ_VIEW_CLOSE,
 127         REQ_NEXT,
 128         REQ_PREVIOUS,
 129
 130         REQ_MOVE_UP,
 131         REQ_MOVE_DOWN,
 132         REQ_MOVE_PAGE_UP,
 133         REQ_MOVE_PAGE_DOWN,
 134         REQ_MOVE_FIRST_LINE,
 135         REQ_MOVE_LAST_LINE,
 136
 137         REQ_SCROLL_LINE_UP,
 138         REQ_SCROLL_LINE_DOWN,
 139         REQ_SCROLL_PAGE_UP,
 140         REQ_SCROLL_PAGE_DOWN,
 141 };
 142
 143 struct ref {
 144         char *name;             /* Ref name; tag or head names are shortened. */
 145         char id[41];            /* Commit SHA1 ID */
 146         unsigned int tag:1;     /* Is it a tag? */
 147         unsigned int next:1;    /* For ref lists: are there more refs? */
 148 };
 149
 150 static struct ref **get_refs(char *id);
 151
 152 struct int_map {
 153         const char *name;
 154         int namelen;
 155         int value;
 156 };
 157
 158 static int
 159 set_from_int_map(struct int_map *map, size_t map_size,
 160                  int *value, const char *name, int namelen)
 161 {
 162
 163         int i;
 164
 165         for (i = 0; i < map_size; i++)
 166                 if (namelen == map[i].namelen &&
 167                     !strncasecmp(name, map[i].name, namelen)) {
 168                         *value = map[i].value;
 169                         return OK;
 170                 }
 171
 172         return ERR;
 173 }
 174
 175
 176 /*
 177  * String helpers
 178  */
 179
 180 static inline void
 181 string_ncopy(char *dst, const char *src, int dstlen)
 182 {
 183         strncpy(dst, src, dstlen - 1);
 184         dst[dstlen - 1] = 0;
 185
 186 }
 187
 188 /* Shorthand for safely copying into a fixed buffer. */
 189 #define string_copy(dst, src) \
 190         string_ncopy(dst, src, sizeof(dst))
 191
 192 static char *
 193 chomp_string(char *name)
 194 {
 195         int namelen;
 196
 197         while (isspace(*name))
 198                 name++;
 199
 200         namelen = strlen(name) - 1;
 201         while (namelen > 0 && isspace(name[namelen]))
 202                 name[namelen--] = 0;
 203
 204         return name;
 205 }
 206
 207
 208 /* Shell quoting
 209  *
 210  * NOTE: The following is a slightly modified copy of the git project's shell
 211  * quoting routines found in the quote.c file.
 212  *
 213  * Help to copy the thing properly quoted for the shell safety.  any single
 214  * quote is replaced with '\'', any exclamation point is replaced with '\!',
 215  * and the whole thing is enclosed in a
 216  *
 217  * E.g.
 218  *  original     sq_quote     result
 219  *  name     ==> name      ==> 'name'
 220  *  a b      ==> a b       ==> 'a b'
 221  *  a'b      ==> a'\''b    ==> 'a'\''b'
 222  *  a!b      ==> a'\!'b    ==> 'a'\!'b'
 223  */
 224
 225 static size_t
 226 sq_quote(char buf[SIZEOF_CMD], size_t bufsize, const char *src)
 227 {
 228         char c;
 229
 230 #define BUFPUT(x) do { if (bufsize < SIZEOF_CMD) buf[bufsize++] = (x); } while (0)
 231
 232         BUFPUT('\'');
 233         while ((c = *src++)) {
 234                 if (c == '\'' || c == '!') {
 235                         BUFPUT('\'');
 236                         BUFPUT('\\');
 237                         BUFPUT(c);
 238                         BUFPUT('\'');
 239                 } else {
 240                         BUFPUT(c);
 241                 }
 242         }
 243         BUFPUT('\'');
 244
 245         return bufsize;
 246 }
 247
 248
 249 /**
 250  * OPTIONS
 251  * -------
 252  **/
 253
 254 static const char usage[] =
 255 VERSION " (" __DATE__ ")\n"
 256 "\n"
 257 "Usage: tig [options]\n"
 258 "   or: tig [options] [--] [git log options]\n"
 259 "   or: tig [options] log  [git log options]\n"
 260 "   or: tig [options] diff [git diff options]\n"
 261 "   or: tig [options] show [git show options]\n"
 262 "   or: tig [options] <    [git command output]\n"
 263 "\n"
 264 "Options:\n"
 265 "  -l                          Start up in log view\n"
 266 "  -d                          Start up in diff view\n"
 267 "  -n[I], --line-number[=I]    Show line numbers with given interval\n"
 268 "  -b[N], --tab-size[=N]       Set number of spaces for tab expansion\n"
 269 "  --                          Mark end of tig options\n"
 270 "  -v, --version               Show version and exit\n"
 271 "  -h, --help                  Show help message and exit\n";
 272
 273 /* Option and state variables. */
 274 static bool opt_line_number     = FALSE;
 275 static int opt_num_interval     = NUMBER_INTERVAL;
 276 static int opt_tab_size         = TABSIZE;
 277 static enum request opt_request = REQ_VIEW_MAIN;
 278 static char opt_cmd[SIZEOF_CMD] = "";
 279 static char opt_encoding[20]    = "";
 280 static bool opt_utf8            = TRUE;
 281 static FILE *opt_pipe           = NULL;
 282
 283 /* Returns the index of log or diff command or -1 to exit. */
 284 static bool
 285 parse_options(int argc, char *argv[])
 286 {
 287         int i;
 288
 289         for (i = 1; i < argc; i++) {
 290                 char *opt = argv[i];
 291
 292                 /**
 293                  * -l::
 294                  *      Start up in log view using the internal log command.
 295                  **/
 296                 if (!strcmp(opt, "-l")) {
 297                         opt_request = REQ_VIEW_LOG;
 298                         continue;
 299                 }
 300
 301                 /**
 302                  * -d::
 303                  *      Start up in diff view using the internal diff command.
 304                  **/
 305                 if (!strcmp(opt, "-d")) {
 306                         opt_request = REQ_VIEW_DIFF;
 307                         continue;
 308                 }
 309
 310                 /**
 311                  * -n[INTERVAL], --line-number[=INTERVAL]::
 312                  *      Prefix line numbers in log and diff view.
 313                  *      Optionally, with interval different than each line.
 314                  **/
 315                 if (!strncmp(opt, "-n", 2) ||
 316                     !strncmp(opt, "--line-number", 13)) {
 317                         char *num = opt;
 318
 319                         if (opt[1] == 'n') {
 320                                 num = opt + 2;
 321
 322                         } else if (opt[STRING_SIZE("--line-number")] == '=') {
 323                                 num = opt + STRING_SIZE("--line-number=");
 324                         }
 325
 326                         if (isdigit(*num))
 327                                 opt_num_interval = atoi(num);
 328
 329                         opt_line_number = TRUE;
 330                         continue;
 331                 }
 332
 333                 /**
 334                  * -b[NSPACES], --tab-size[=NSPACES]::
 335                  *      Set the number of spaces tabs should be expanded to.
 336                  **/
 337                 if (!strncmp(opt, "-b", 2) ||
 338                     !strncmp(opt, "--tab-size", 10)) {
 339                         char *num = opt;
 340
 341                         if (opt[1] == 'b') {
 342                                 num = opt + 2;
 343
 344                         } else if (opt[STRING_SIZE("--tab-size")] == '=') {
 345                                 num = opt + STRING_SIZE("--tab-size=");
 346                         }
 347
 348                         if (isdigit(*num))
 349                                 opt_tab_size = MIN(atoi(num), TABSIZE);
 350                         continue;
 351                 }
 352
 353                 /**
 354                  * -v, --version::
 355                  *      Show version and exit.
 356                  **/
 357                 if (!strcmp(opt, "-v") ||
 358                     !strcmp(opt, "--version")) {
 359                         printf("tig version %s\n", VERSION);
 360                         return FALSE;
 361                 }
 362
 363                 /**
 364                  * -h, --help::
 365                  *      Show help message and exit.
 366                  **/
 367                 if (!strcmp(opt, "-h") ||
 368                     !strcmp(opt, "--help")) {
 369                         printf(usage);
 370                         return FALSE;
 371                 }
 372
 373                 /**
 374                  * \--::
 375                  *      End of tig(1) options. Useful when specifying command
 376                  *      options for the main view. Example:
 377                  *
 378                  *              $ tig -- --since=1.month
 379                  **/
 380                 if (!strcmp(opt, "--")) {
 381                         i++;
 382                         break;
 383                 }
 384
 385                 /**
 386                  * log [git log options]::
 387                  *      Open log view using the given git log options.
 388                  *
 389                  * diff [git diff options]::
 390                  *      Open diff view using the given git diff options.
 391                  *
 392                  * show [git show options]::
 393                  *      Open diff view using the given git show options.
 394                  **/
 395                 if (!strcmp(opt, "log") ||
 396                     !strcmp(opt, "diff") ||
 397                     !strcmp(opt, "show")) {
 398                         opt_request = opt[0] == 'l'
 399                                     ? REQ_VIEW_LOG : REQ_VIEW_DIFF;
 400                         break;
 401                 }
 402
 403                 /**
 404                  * [git log options]::
 405                  *      tig(1) will stop the option parsing when the first
 406                  *      command line parameter not starting with "-" is
 407                  *      encountered. All options including this one will be
 408                  *      passed to git log when loading the main view.
 409                  *      This makes it possible to say:
 410                  *
 411                  *      $ tig tag-1.0..HEAD
 412                  **/
 413                 if (opt[0] && opt[0] != '-')
 414                         break;
 415
 416                 die("unknown command '%s'", opt);
 417         }
 418
 419         if (!isatty(STDIN_FILENO)) {
 420                 /**
 421                  * Pager mode
 422                  * ~~~~~~~~~~
 423                  * If stdin is a pipe, any log or diff options will be ignored and the
 424                  * pager view will be opened loading data from stdin. The pager mode
 425                  * can be used for colorizing output from various git commands.
 426                  *
 427                  * Example on how to colorize the output of git-show(1):
 428                  *
 429                  *      $ git show | tig
 430                  **/
 431                 opt_request = REQ_VIEW_PAGER;
 432                 opt_pipe = stdin;
 433
 434         } else if (i < argc) {
 435                 size_t buf_size;
 436
 437                 /**
 438                  * Git command options
 439                  * ~~~~~~~~~~~~~~~~~~~
 440                  * All git command options specified on the command line will
 441                  * be passed to the given command and all will be shell quoted
 442                  * before they are passed to the shell.
 443                  *
 444                  * NOTE: If you specify options for the main view, you should
 445                  * not use the `--pretty` option as this option will be set
 446                  * automatically to the format expected by the main view.
 447                  *
 448                  * Example on how to open the log view and show both author and
 449                  * committer information:
 450                  *
 451                  *      $ tig log --pretty=fuller
 452                  *
 453                  * See the <<refspec, "Specifying revisions">> section below
 454                  * for an introduction to revision options supported by the git
 455                  * commands. For details on specific git command options, refer
 456                  * to the man page of the command in question.
 457                  **/
 458
 459                 if (opt_request == REQ_VIEW_MAIN)
 460                         /* XXX: This is vulnerable to the user overriding
 461                          * options required for the main view parser. */
 462                         string_copy(opt_cmd, "git log --stat --pretty=raw");
 463                 else
 464                         string_copy(opt_cmd, "git");
 465                 buf_size = strlen(opt_cmd);
 466
 467                 while (buf_size < sizeof(opt_cmd) && i < argc) {
 468                         opt_cmd[buf_size++] = ' ';
 469                         buf_size = sq_quote(opt_cmd, buf_size, argv[i++]);
 470                 }
 471
 472                 if (buf_size >= sizeof(opt_cmd))
 473                         die("command too long");
 474
 475                 opt_cmd[buf_size] = 0;
 476
 477         }
 478
 479         if (*opt_encoding && strcasecmp(opt_encoding, "UTF-8"))
 480                 opt_utf8 = FALSE;
 481
 482         return TRUE;
 483 }
 484
 485
 486 /**
 487  * ENVIRONMENT VARIABLES
 488  * ---------------------
 489  * Several options related to the interface with git can be configured
 490  * via environment options.
 491  *
 492  * Repository references
 493  * ~~~~~~~~~~~~~~~~~~~~~
 494  * Commits that are referenced by tags and branch heads will be marked
 495  * by the reference name surrounded by '[' and ']':
 496  *
 497  *      2006-03-26 19:42 Petr Baudis         | [cogito-0.17.1] Cogito 0.17.1
 498  *
 499  * If you want to filter out certain directories under `.git/refs/`, say
 500  * `tmp` you can do it by setting the following variable:
 501  *
 502  *      $ TIG_LS_REMOTE="git ls-remote . | sed /\/tmp\//d" tig
 503  *
 504  * Or set the variable permanently in your environment.
 505  *
 506  * TIG_LS_REMOTE::
 507  *      Set command for retrieving all repository references. The command
 508  *      should output data in the same format as git-ls-remote(1).
 509  **/
 510
 511 #define TIG_LS_REMOTE \
 512         "git ls-remote . 2>/dev/null"
 513
 514 /**
 515  * [[history-commands]]
 516  * History commands
 517  * ~~~~~~~~~~~~~~~~
 518  * It is possible to alter which commands are used for the different views.
 519  * If for example you prefer commits in the main view to be sorted by date
 520  * and only show 500 commits, use:
 521  *
 522  *      $ TIG_MAIN_CMD="git log --date-order -n500 --pretty=raw %s" tig
 523  *
 524  * Or set the variable permanently in your environment.
 525  *
 526  * Notice, how `%s` is used to specify the commit reference. There can
 527  * be a maximum of 5 `%s` ref specifications.
 528  *
 529  * TIG_DIFF_CMD::
 530  *      The command used for the diff view. By default, git show is used
 531  *      as a backend.
 532  *
 533  * TIG_LOG_CMD::
 534  *      The command used for the log view. If you prefer to have both
 535  *      author and committer shown in the log view be sure to pass
 536  *      `--pretty=fuller` to git log.
 537  *
 538  * TIG_MAIN_CMD::
 539  *      The command used for the main view. Note, you must always specify
 540  *      the option: `--pretty=raw` since the main view parser expects to
 541  *      read that format.
 542  **/
 543
 544 #define TIG_DIFF_CMD \
 545         "git show --patch-with-stat --find-copies-harder -B -C %s"
 546
 547 #define TIG_LOG_CMD     \
 548         "git log --cc --stat -n100 %s"
 549
 550 #define TIG_MAIN_CMD \
 551         "git log --topo-order --stat --pretty=raw %s"
 552
 553 /* ... silently ignore that the following are also exported. */
 554
 555 #define TIG_HELP_CMD \
 556         "man tig 2>/dev/null"
 557
 558 #define TIG_PAGER_CMD \
 559         ""
 560
 561
 562 /**
 563  * FILES
 564  * -----
 565  * '~/.tig'::
 566  *      User configuration file. See "<<config-options, Configuration options>>"
 567  *      section for examples.
 568  *
 569  * '.git/config'::
 570  *      Repository config file. Read on startup with the help of
 571  *      git-repo-config(1).
 572  **/
 573 /**
 574  * [[config-options]]
 575  * User Configuration file
 576  * -----------------------
 577  * You can permanently set an option by putting it in the `~/.tig` file.
 578  * The file consists of a series of 'commands'.  Each
 579  * line of the file may contain only one command.
 580  *
 581  * The hash mark ('#'), or semi-colon (';') is used as a 'comment' character.
 582  * All text after the comment character to the end of the line is ignored.
 583  * You can use comments to annotate your initialization file.
 584  *
 585  * Configuration Commands
 586  * ~~~~~~~~~~~~~~~~~~~~~~
 587  *
 588  * --
 589  *
 590  * *color* object fgcolor bgcolor [attributes]::
 591  *
 592  * If  your terminal supports color, these commands can be used to assign
 593  * foreground/backgound combinations to certain objects. Optionally, an
 594  * attribute can be given as the last parameter.
 595  *
 596  * Valid objects are described in the "<<color-objs, Color objects>>" section
 597  * below. Note, object names are case-insensitive, and you may use '-', '_',
 598  * and '.' interchangeably. So "Diff-Header", "DIFF_HEADER", and "diff.header"
 599  * are the same.
 600  *
 601  * Valid colors include: 'white', 'black', 'green', 'magenta', 'blue', 'cyan',
 602  * 'yellow', 'red', 'default'. Use 'default' to refer to the default terminal
 603  * colors.
 604  **/
 605
 606 static struct int_map color_map[] = {
 607 #define COLOR_MAP(name) { #name, STRING_SIZE(#name), COLOR_##name }
 608         COLOR_MAP(DEFAULT),
 609         COLOR_MAP(BLACK),
 610         COLOR_MAP(BLUE),
 611         COLOR_MAP(CYAN),
 612         COLOR_MAP(GREEN),
 613         COLOR_MAP(MAGENTA),
 614         COLOR_MAP(RED),
 615         COLOR_MAP(WHITE),
 616         COLOR_MAP(YELLOW),
 617 };
 618
 619 /**
 620  * Valid attributes include: 'normal', 'blink', 'bold', 'dim', 'reverse', 'standout',
 621  * and 'underline'. Note, not all attributes may be supported by the terminal.
 622  **/
 623
 624 static struct int_map attr_map[] = {
 625 #define ATTR_MAP(name) { #name, STRING_SIZE(#name), A_##name }
 626         ATTR_MAP(NORMAL),
 627         ATTR_MAP(BLINK),
 628         ATTR_MAP(BOLD),
 629         ATTR_MAP(DIM),
 630         ATTR_MAP(REVERSE),
 631         ATTR_MAP(STANDOUT),
 632         ATTR_MAP(UNDERLINE),
 633 };
 634
 635 /**
 636  * Some example color options:
 637  *
 638  * --------------------------------------------------------------------------
 639  *      # Diff colors
 640  *      color diff-header       yellow  default
 641  *      color diff-index        blue    default
 642  *      color diff-chunk        magenta default
 643  *      # UI colors
 644  *      color title-blur        white   blue
 645  *      color title-focus       white   blue    bold
 646  * --------------------------------------------------------------------------
 647  *
 648  * --
 649  **/
 650
 651 /**
 652  * [[color-objs]]
 653  * Color objects
 654  * ~~~~~~~~~~~~~
 655  *
 656  * --
 657  **/
 658
 659 #define LINE_INFO \
 660 /**
 661  * Diff markup::
 662  *
 663  * Objects concerning diff start, chunks and lines added and deleted.
 664  *
 665  * 'diff-header', 'diff-chunk', 'diff-add', 'diff-del'
 666  **/ \
 667 LINE(DIFF_HEADER,  "diff --git ",       COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 668 LINE(DIFF_CHUNK,   "@@",                COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
 669 LINE(DIFF_ADD,     "+",                 COLOR_GREEN,    COLOR_DEFAULT,  0), \
 670 LINE(DIFF_DEL,     "-",                 COLOR_RED,      COLOR_DEFAULT,  0), \
 671 /**
 672  * Enhanced git diff markup::
 673  *
 674  * Extra diff information emitted by the git diff machinery, such as mode
 675  * changes, rename detection, and similarity.
 676  *
 677  * 'diff-oldmode', 'diff-newmode', 'diff-copy-from', 'diff-copy-to',
 678  * 'diff-rename-from', 'diff-rename-to', 'diff-similarity' 'diff-dissimilarity'
 679  * 'diff-tree', 'diff-index'
 680  **/ \
 681 LINE(DIFF_INDEX,        "index ",         COLOR_BLUE,   COLOR_DEFAULT,  0), \
 682 LINE(DIFF_OLDMODE,      "old file mode ", COLOR_YELLOW, COLOR_DEFAULT,  0), \
 683 LINE(DIFF_NEWMODE,      "new file mode ", COLOR_YELLOW, COLOR_DEFAULT,  0), \
 684 LINE(DIFF_COPY_FROM,    "copy from",      COLOR_YELLOW, COLOR_DEFAULT,  0), \
 685 LINE(DIFF_COPY_TO,      "copy to",        COLOR_YELLOW, COLOR_DEFAULT,  0), \
 686 LINE(DIFF_RENAME_FROM,  "rename from",    COLOR_YELLOW, COLOR_DEFAULT,  0), \
 687 LINE(DIFF_RENAME_TO,    "rename to",      COLOR_YELLOW, COLOR_DEFAULT,  0), \
 688 LINE(DIFF_SIMILARITY,   "similarity ",    COLOR_YELLOW, COLOR_DEFAULT,  0), \
 689 LINE(DIFF_DISSIMILARITY,"dissimilarity ", COLOR_YELLOW, COLOR_DEFAULT,  0), \
 690 LINE(DIFF_TREE,         "diff-tree ",     COLOR_BLUE,   COLOR_DEFAULT,  0), \
 691 /**
 692  * Pretty print commit headers::
 693  *
 694  * Commit diffs and the revision logs are usually formatted using pretty
 695  * printed headers , unless `--pretty=raw` was given. This includes lines,
 696  * such as merge info, commit ID, and author and comitter date.
 697  *
 698  * 'pp-author' 'pp-commit' 'pp-merge' 'pp-date' 'pp-adate' 'pp-cdate'
 699  **/ \
 700 LINE(PP_AUTHOR,    "Author: ",          COLOR_CYAN,     COLOR_DEFAULT,  0), \
 701 LINE(PP_COMMIT,    "Commit: ",          COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
 702 LINE(PP_MERGE,     "Merge: ",           COLOR_BLUE,     COLOR_DEFAULT,  0), \
 703 LINE(PP_DATE,      "Date:   ",          COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 704 LINE(PP_ADATE,     "AuthorDate: ",      COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 705 LINE(PP_CDATE,     "CommitDate: ",      COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 706 /**
 707  * Raw commit header::
 708  *
 709  * Usually shown when `--pretty=raw` is given, however 'commit' is pretty
 710  * much omnipresent.
 711  *
 712  * 'commit' 'parent' 'tree' 'author' 'committer'
 713  **/ \
 714 LINE(COMMIT,       "commit ",           COLOR_GREEN,    COLOR_DEFAULT,  0), \
 715 LINE(PARENT,       "parent ",           COLOR_BLUE,     COLOR_DEFAULT,  0), \
 716 LINE(TREE,         "tree ",             COLOR_BLUE,     COLOR_DEFAULT,  0), \
 717 LINE(AUTHOR,       "author ",           COLOR_CYAN,     COLOR_DEFAULT,  0), \
 718 LINE(COMMITTER,    "committer ",        COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
 719 /**
 720  * Commit message::
 721  *
 722  * For now only `Signed-off-by lines` are colorized.
 723  *
 724  * 'signoff'
 725  **/ \
 726 LINE(SIGNOFF,      "    Signed-off-by", COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 727 /**
 728  * UI colors::
 729  *
 730  * Colors for text not matching any of the above: 'default'
 731  *
 732  * Status window colors: 'status'
 733  *
 734  * Title window colors: 'title-blur' 'title-focus'
 735  *
 736  * Cursor line colors: 'cursor'
 737  *
 738  * Main view specific: 'main-date' 'main-author' 'main-commit' 'main-delim'
 739  * 'main-tag' 'main-ref'
 740  **/ \
 741 LINE(DEFAULT,      "",                  COLOR_DEFAULT,  COLOR_DEFAULT,  A_NORMAL), \
 742 LINE(CURSOR,       "",                  COLOR_WHITE,    COLOR_GREEN,    A_BOLD), \
 743 LINE(STATUS,       "",                  COLOR_GREEN,    COLOR_DEFAULT,  0), \
 744 LINE(TITLE_BLUR,   "",                  COLOR_WHITE,    COLOR_BLUE,     0), \
 745 LINE(TITLE_FOCUS,  "",                  COLOR_WHITE,    COLOR_BLUE,     A_BOLD), \
 746 LINE(MAIN_DATE,    "",                  COLOR_BLUE,     COLOR_DEFAULT,  0), \
 747 LINE(MAIN_AUTHOR,  "",                  COLOR_GREEN,    COLOR_DEFAULT,  0), \
 748 LINE(MAIN_COMMIT,  "",                  COLOR_DEFAULT,  COLOR_DEFAULT,  0), \
 749 LINE(MAIN_DELIM,   "",                  COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
 750 LINE(MAIN_TAG,     "",                  COLOR_MAGENTA,  COLOR_DEFAULT,  A_BOLD), \
 751 LINE(MAIN_REF,     "",                  COLOR_CYAN,     COLOR_DEFAULT,  A_BOLD), \
 752 /**
 753  * --
 754  **/
 755
 756
 757 /*
 758  * Line-oriented content detection.
 759  */
 760
 761 enum line_type {
 762 #define LINE(type, line, fg, bg, attr) \
 763         LINE_##type
 764         LINE_INFO
 765 #undef  LINE
 766 };
 767
 768 struct line_info {
 769         const char *name;       /* Option name. */
 770         int namelen;            /* Size of option name. */
 771         const char *line;       /* The start of line to match. */
 772         int linelen;            /* Size of string to match. */
 773         int fg, bg, attr;       /* Color and text attributes for the lines. */
 774 };
 775
 776 static struct line_info line_info[] = {
 777 #define LINE(type, line, fg, bg, attr) \
 778         { #type, STRING_SIZE(#type), (line), STRING_SIZE(line), (fg), (bg), (attr) }
 779         LINE_INFO
 780 #undef  LINE
 781 };
 782
 783 static enum line_type
 784 get_line_type(char *line)
 785 {
 786         int linelen = strlen(line);
 787         enum line_type type;
 788
 789         for (type = 0; type < ARRAY_SIZE(line_info); type++)
 790                 /* Case insensitive search matches Signed-off-by lines better. */
 791                 if (linelen >= line_info[type].linelen &&
 792                     !strncasecmp(line_info[type].line, line, line_info[type].linelen))
 793                         return type;
 794
 795         return LINE_DEFAULT;
 796 }
 797
 798 static inline int
 799 get_line_attr(enum line_type type)
 800 {
 801         assert(type < ARRAY_SIZE(line_info));
 802         return COLOR_PAIR(type) | line_info[type].attr;
 803 }
 804
 805 static struct line_info *
 806 get_line_info(char *name, int namelen)
 807 {
 808         enum line_type type;
 809         int i;
 810
 811         /* Diff-Header -> DIFF_HEADER */
 812         for (i = 0; i < namelen; i++) {
 813                 if (name[i] == '-')
 814                         name[i] = '_';
 815                 else if (name[i] == '.')
 816                         name[i] = '_';
 817         }
 818
 819         for (type = 0; type < ARRAY_SIZE(line_info); type++)
 820                 if (namelen == line_info[type].namelen &&
 821                     !strncasecmp(line_info[type].name, name, namelen))
 822                         return &line_info[type];
 823
 824         return NULL;
 825 }
 826
 827 static void
 828 init_colors(void)
 829 {
 830         int default_bg = COLOR_BLACK;
 831         int default_fg = COLOR_WHITE;
 832         enum line_type type;
 833
 834         start_color();
 835
 836         if (use_default_colors() != ERR) {
 837                 default_bg = -1;
 838                 default_fg = -1;
 839         }
 840
 841         for (type = 0; type < ARRAY_SIZE(line_info); type++) {
 842                 struct line_info *info = &line_info[type];
 843                 int bg = info->bg == COLOR_DEFAULT ? default_bg : info->bg;
 844                 int fg = info->fg == COLOR_DEFAULT ? default_fg : info->fg;
 845
 846                 init_pair(type, fg, bg);
 847         }
 848 }
 849
 850 struct line {
 851         enum line_type type;
 852         void *data;             /* User data */
 853 };
 854
 855
 856 #define set_color(color, name, namelen) \
 857         set_from_int_map(color_map, ARRAY_SIZE(color_map), color, name, namelen)
 858
 859 #define set_attribute(attr, name, namelen) \
 860         set_from_int_map(attr_map, ARRAY_SIZE(attr_map), attr, name, namelen)
 861
 862 static int
 863 read_option(char *opt, int optlen, char *value, int valuelen)
 864 {
 865         optlen = strcspn(opt, "#;");
 866         if (optlen == 0)
 867                 /* The whole line is a comment. */
 868                 return OK;
 869
 870         else if (opt[optlen] != 0)
 871                 /* Part of the option name is a comment, so the value part
 872                  * should be ignored. */
 873                 valuelen = 0;
 874         else
 875                 /* Else look for comment endings in the value. */
 876                 valuelen = strcspn(value, "#;");
 877
 878         opt[optlen] = value[valuelen] = 0;
 879
 880         /* Reads: "color" object fgcolor bgcolor [attr] */
 881         if (!strcmp(opt, "color")) {
 882                 struct line_info *info;
 883
 884                 value = chomp_string(value);
 885                 valuelen = strcspn(value, " \t");
 886                 info = get_line_info(value, valuelen);
 887                 if (!info)
 888                         return ERR;
 889
 890                 value = chomp_string(value + valuelen);
 891                 valuelen = strcspn(value, " \t");
 892                 if (set_color(&info->fg, value, valuelen) == ERR)
 893                         return ERR;
 894
 895                 value = chomp_string(value + valuelen);
 896                 valuelen = strcspn(value, " \t");
 897                 if (set_color(&info->bg, value, valuelen) == ERR)
 898                         return ERR;
 899
 900                 value = chomp_string(value + valuelen);
 901                 if (*value &&
 902                     set_attribute(&info->attr, value, strlen(value)) == ERR)
 903                         return ERR;
 904
 905                 return OK;
 906         }
 907
 908         return ERR;
 909 }
 910
 911 static int
 912 load_options(void)
 913 {
 914         char *home = getenv("HOME");
 915         char buf[1024];
 916         FILE *file;
 917
 918         if (!home ||
 919             snprintf(buf, sizeof(buf), "%s/.tig", home) >= sizeof(buf))
 920                 return ERR;
 921
 922         /* It's ok that the file doesn't exist. */
 923         file = fopen(buf, "r");
 924         if (!file)
 925                 return OK;
 926
 927         return read_properties(file, " \t", read_option);
 928 }
 929
 930
 931 /**
 932  * The viewer
 933  * ----------
 934  * The display consists of a status window on the last line of the screen and
 935  * one or more views. The default is to only show one view at the time but it
 936  * is possible to split both the main and log view to also show the commit
 937  * diff.
 938  *
 939  * If you are in the log view and press 'Enter' when the current line is a
 940  * commit line, such as:
 941  *
 942  *      commit 4d55caff4cc89335192f3e566004b4ceef572521
 943  *
 944  * You will split the view so that the log view is displayed in the top window
 945  * and the diff view in the bottom window. You can switch between the two
 946  * views by pressing 'Tab'. To maximize the log view again, simply press 'l'.
 947  **/
 948
 949 struct view;
 950 struct view_ops;
 951
 952 /* The display array of active views and the index of the current view. */
 953 static struct view *display[2];
 954 static unsigned int current_view;
 955
 956 #define foreach_view(view, i) \
 957         for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
 958
 959 #define displayed_views()       (display[1] != NULL ? 2 : 1)
 960
 961 /**
 962  * Current head and commit ID
 963  * ~~~~~~~~~~~~~~~~~~~~~~~~~~
 964  * The viewer keeps track of both what head and commit ID you are currently
 965  * viewing. The commit ID will follow the cursor line and change everytime time
 966  * you highlight a different commit. Whenever you reopen the diff view it
 967  * will be reloaded, if the commit ID changed.
 968  *
 969  * The head ID is used when opening the main and log view to indicate from
 970  * what revision to show history.
 971  **/
 972
 973 static char ref_commit[SIZEOF_REF]      = "HEAD";
 974 static char ref_head[SIZEOF_REF]        = "HEAD";
 975
 976 struct view {
 977         const char *name;       /* View name */
 978         const char *cmd_fmt;    /* Default command line format */
 979         const char *cmd_env;    /* Command line set via environment */
 980         const char *id;         /* Points to either of ref_{head,commit} */
 981
 982         struct view_ops *ops;   /* View operations */
 983
 984         char cmd[SIZEOF_CMD];   /* Command buffer */
 985         char ref[SIZEOF_REF];   /* Hovered commit reference */
 986         char vid[SIZEOF_REF];   /* View ID. Set to id member when updating. */
 987
 988         int height, width;      /* The width and height of the main window */
 989         WINDOW *win;            /* The main window */
 990         WINDOW *title;          /* The title window living below the main window */
 991
 992         /* Navigation */
 993         unsigned long offset;   /* Offset of the window top */
 994         unsigned long lineno;   /* Current line number */
 995
 996         /* If non-NULL, points to the view that opened this view. If this view
 997          * is closed tig will switch back to the parent view. */
 998         struct view *parent;
 999
1000         /* Buffering */
1001         unsigned long lines;    /* Total number of lines */
1002         struct line *line;      /* Line index */
1003         unsigned int digits;    /* Number of digits in the lines member. */
1004
1005         /* Loading */
1006         FILE *pipe;
1007         time_t start_time;
1008 };
1009
1010 struct view_ops {
1011         /* What type of content being displayed. Used in the title bar. */
1012         const char *type;
1013         /* Draw one line; @lineno must be < view->height. */
1014         bool (*draw)(struct view *view, struct line *line, unsigned int lineno);
1015         /* Read one line; updates view->line. */
1016         bool (*read)(struct view *view, struct line *prev, char *data);
1017         /* Depending on view, change display based on current line. */
1018         bool (*enter)(struct view *view, struct line *line);
1019 };
1020
1021 static struct view_ops pager_ops;
1022 static struct view_ops main_ops;
1023
1024 #define VIEW_STR(name, cmd, env, ref, ops) \
1025         { name, cmd, #env, ref, ops }
1026
1027 #define VIEW_(id, name, ops, ref) \
1028         VIEW_STR(name, TIG_##id##_CMD,  TIG_##id##_CMD, ref, ops)
1029
1030 /**
1031  * Views
1032  * ~~~~~
1033  * tig(1) presents various 'views' of a repository. Each view is based on output
1034  * from an external command, most often 'git log', 'git diff', or 'git show'.
1035  *
1036  * The main view::
1037  *      Is the default view, and it shows a one line summary of each commit
1038  *      in the chosen list of revisions. The summary includes commit date,
1039  *      author, and the first line of the log message. Additionally, any
1040  *      repository references, such as tags, will be shown.
1041  *
1042  * The log view::
1043  *      Presents a more rich view of the revision log showing the whole log
1044  *      message and the diffstat.
1045  *
1046  * The diff view::
1047  *      Shows either the diff of the current working tree, that is, what
1048  *      has changed since the last commit, or the commit diff complete
1049  *      with log message, diffstat and diff.
1050  *
1051  * The pager view::
1052  *      Is used for displaying both input from stdin and output from git
1053  *      commands entered in the internal prompt.
1054  *
1055  * The help view::
1056  *      Displays the information from the tig(1) man page. For the help view
1057  *      to work you need to have the tig(1) man page installed.
1058  **/
1059
1060 static struct view views[] = {
1061         VIEW_(MAIN,  "main",  &main_ops,  ref_head),
1062         VIEW_(DIFF,  "diff",  &pager_ops, ref_commit),
1063         VIEW_(LOG,   "log",   &pager_ops, ref_head),
1064         VIEW_(HELP,  "help",  &pager_ops, "static"),
1065         VIEW_(PAGER, "pager", &pager_ops, "static"),
1066 };
1067
1068 #define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
1069
1070
1071 static bool
1072 draw_view_line(struct view *view, unsigned int lineno)
1073 {
1074         if (view->offset + lineno >= view->lines)
1075                 return FALSE;
1076
1077         return view->ops->draw(view, &view->line[view->offset + lineno], lineno);
1078 }
1079
1080 static void
1081 redraw_view_from(struct view *view, int lineno)
1082 {
1083         assert(0 <= lineno && lineno < view->height);
1084
1085         for (; lineno < view->height; lineno++) {
1086                 if (!draw_view_line(view, lineno))
1087                         break;
1088         }
1089
1090         redrawwin(view->win);
1091         wrefresh(view->win);
1092 }
1093
1094 static void
1095 redraw_view(struct view *view)
1096 {
1097         wclear(view->win);
1098         redraw_view_from(view, 0);
1099 }
1100
1101
1102 /**
1103  * Title windows
1104  * ~~~~~~~~~~~~~
1105  * Each view has a title window which shows the name of the view, current
1106  * commit ID if available, and where the view is positioned:
1107  *
1108  *      [main] c622eefaa485995320bc743431bae0d497b1d875 - commit 1 of 61 (1%)
1109  *
1110  * By default, the title of the current view is highlighted using bold font.
1111  * For long loading views (taking over 3 seconds) the time since loading
1112  * started will be appended:
1113  *
1114  *      [main] 77d9e40fbcea3238015aea403e06f61542df9a31 - commit 1 of 779 (0%) 5s
1115  **/
1116
1117 static void
1118 update_view_title(struct view *view)
1119 {
1120         if (view == display[current_view])
1121                 wbkgdset(view->title, get_line_attr(LINE_TITLE_FOCUS));
1122         else
1123                 wbkgdset(view->title, get_line_attr(LINE_TITLE_BLUR));
1124
1125         werase(view->title);
1126         wmove(view->title, 0, 0);
1127
1128         if (*view->ref)
1129                 wprintw(view->title, "[%s] %s", view->name, view->ref);
1130         else
1131                 wprintw(view->title, "[%s]", view->name);
1132
1133         if (view->lines || view->pipe) {
1134                 unsigned int lines = view->lines
1135                                    ? (view->lineno + 1) * 100 / view->lines
1136                                    : 0;
1137
1138                 wprintw(view->title, " - %s %d of %d (%d%%)",
1139                         view->ops->type,
1140                         view->lineno + 1,
1141                         view->lines,
1142                         lines);
1143         }
1144
1145         if (view->pipe) {
1146                 time_t secs = time(NULL) - view->start_time;
1147
1148                 /* Three git seconds are a long time ... */
1149                 if (secs > 2)
1150                         wprintw(view->title, " %lds", secs);
1151         }
1152
1153         wmove(view->title, 0, view->width - 1);
1154         wrefresh(view->title);
1155 }
1156
1157 static void
1158 resize_display(void)
1159 {
1160         int offset, i;
1161         struct view *base = display[0];
1162         struct view *view = display[1] ? display[1] : display[0];
1163
1164         /* Setup window dimensions */
1165
1166         getmaxyx(stdscr, base->height, base->width);
1167
1168         /* Make room for the status window. */
1169         base->height -= 1;
1170
1171         if (view != base) {
1172                 /* Horizontal split. */
1173                 view->width   = base->width;
1174                 view->height  = SCALE_SPLIT_VIEW(base->height);
1175                 base->height -= view->height;
1176
1177                 /* Make room for the title bar. */
1178                 view->height -= 1;
1179         }
1180
1181         /* Make room for the title bar. */
1182         base->height -= 1;
1183
1184         offset = 0;
1185
1186         foreach_view (view, i) {
1187                 if (!view->win) {
1188                         view->win = newwin(view->height, 0, offset, 0);
1189                         if (!view->win)
1190                                 die("Failed to create %s view", view->name);
1191
1192                         scrollok(view->win, TRUE);
1193
1194                         view->title = newwin(1, 0, offset + view->height, 0);
1195                         if (!view->title)
1196                                 die("Failed to create title window");
1197
1198                 } else {
1199                         wresize(view->win, view->height, view->width);
1200                         mvwin(view->win,   offset, 0);
1201                         mvwin(view->title, offset + view->height, 0);
1202                 }
1203
1204                 offset += view->height + 1;
1205         }
1206 }
1207
1208 static void
1209 redraw_display(void)
1210 {
1211         struct view *view;
1212         int i;
1213
1214         foreach_view (view, i) {
1215                 redraw_view(view);
1216                 update_view_title(view);
1217         }
1218 }
1219
1220 static void
1221 update_display_cursor(void)
1222 {
1223         struct view *view = display[current_view];
1224
1225         /* Move the cursor to the right-most column of the cursor line.
1226          *
1227          * XXX: This could turn out to be a bit expensive, but it ensures that
1228          * the cursor does not jump around. */
1229         if (view->lines) {
1230                 wmove(view->win, view->lineno - view->offset, view->width - 1);
1231                 wrefresh(view->win);
1232         }
1233 }
1234
1235 /*
1236  * Navigation
1237  */
1238
1239 /* Scrolling backend */
1240 static void
1241 do_scroll_view(struct view *view, int lines, bool redraw)
1242 {
1243         /* The rendering expects the new offset. */
1244         view->offset += lines;
1245
1246         assert(0 <= view->offset && view->offset < view->lines);
1247         assert(lines);
1248
1249         /* Redraw the whole screen if scrolling is pointless. */
1250         if (view->height < ABS(lines)) {
1251                 redraw_view(view);
1252
1253         } else {
1254                 int line = lines > 0 ? view->height - lines : 0;
1255                 int end = line + ABS(lines);
1256
1257                 wscrl(view->win, lines);
1258
1259                 for (; line < end; line++) {
1260                         if (!draw_view_line(view, line))
1261                                 break;
1262                 }
1263         }
1264
1265         /* Move current line into the view. */
1266         if (view->lineno < view->offset) {
1267                 view->lineno = view->offset;
1268                 draw_view_line(view, 0);
1269
1270         } else if (view->lineno >= view->offset + view->height) {
1271                 if (view->lineno == view->offset + view->height) {
1272                         /* Clear the hidden line so it doesn't show if the view
1273                          * is scrolled up. */
1274                         wmove(view->win, view->height, 0);
1275                         wclrtoeol(view->win);
1276                 }
1277                 view->lineno = view->offset + view->height - 1;
1278                 draw_view_line(view, view->lineno - view->offset);
1279         }
1280
1281         assert(view->offset <= view->lineno && view->lineno < view->lines);
1282
1283         if (!redraw)
1284                 return;
1285
1286         redrawwin(view->win);
1287         wrefresh(view->win);
1288         report("");
1289 }
1290
1291 /* Scroll frontend */
1292 static void
1293 scroll_view(struct view *view, enum request request)
1294 {
1295         int lines = 1;
1296
1297         switch (request) {
1298         case REQ_SCROLL_PAGE_DOWN:
1299                 lines = view->height;
1300         case REQ_SCROLL_LINE_DOWN:
1301                 if (view->offset + lines > view->lines)
1302                         lines = view->lines - view->offset;
1303
1304                 if (lines == 0 || view->offset + view->height >= view->lines) {
1305                         report("Cannot scroll beyond the last line");
1306                         return;
1307                 }
1308                 break;
1309
1310         case REQ_SCROLL_PAGE_UP:
1311                 lines = view->height;
1312         case REQ_SCROLL_LINE_UP:
1313                 if (lines > view->offset)
1314                         lines = view->offset;
1315
1316                 if (lines == 0) {
1317                         report("Cannot scroll beyond the first line");
1318                         return;
1319                 }
1320
1321                 lines = -lines;
1322                 break;
1323
1324         default:
1325                 die("request %d not handled in switch", request);
1326         }
1327
1328         do_scroll_view(view, lines, TRUE);
1329 }
1330
1331 /* Cursor moving */
1332 static void
1333 move_view(struct view *view, enum request request, bool redraw)
1334 {
1335         int steps;
1336
1337         switch (request) {
1338         case REQ_MOVE_FIRST_LINE:
1339                 steps = -view->lineno;
1340                 break;
1341
1342         case REQ_MOVE_LAST_LINE:
1343                 steps = view->lines - view->lineno - 1;
1344                 break;
1345
1346         case REQ_MOVE_PAGE_UP:
1347                 steps = view->height > view->lineno
1348                       ? -view->lineno : -view->height;
1349                 break;
1350
1351         case REQ_MOVE_PAGE_DOWN:
1352                 steps = view->lineno + view->height >= view->lines
1353                       ? view->lines - view->lineno - 1 : view->height;
1354                 break;
1355
1356         case REQ_MOVE_UP:
1357                 steps = -1;
1358                 break;
1359
1360         case REQ_MOVE_DOWN:
1361                 steps = 1;
1362                 break;
1363
1364         default:
1365                 die("request %d not handled in switch", request);
1366         }
1367
1368         if (steps <= 0 && view->lineno == 0) {
1369                 report("Cannot move beyond the first line");
1370                 return;
1371
1372         } else if (steps >= 0 && view->lineno + 1 >= view->lines) {
1373                 report("Cannot move beyond the last line");
1374                 return;
1375         }
1376
1377         /* Move the current line */
1378         view->lineno += steps;
1379         assert(0 <= view->lineno && view->lineno < view->lines);
1380
1381         /* Repaint the old "current" line if we be scrolling */
1382         if (ABS(steps) < view->height) {
1383                 int prev_lineno = view->lineno - steps - view->offset;
1384
1385                 wmove(view->win, prev_lineno, 0);
1386                 wclrtoeol(view->win);
1387                 draw_view_line(view,  prev_lineno);
1388         }
1389
1390         /* Check whether the view needs to be scrolled */
1391         if (view->lineno < view->offset ||
1392             view->lineno >= view->offset + view->height) {
1393                 if (steps < 0 && -steps > view->offset) {
1394                         steps = -view->offset;
1395
1396                 } else if (steps > 0) {
1397                         if (view->lineno == view->lines - 1 &&
1398                             view->lines > view->height) {
1399                                 steps = view->lines - view->offset - 1;
1400                                 if (steps >= view->height)
1401                                         steps -= view->height - 1;
1402                         }
1403                 }
1404
1405                 do_scroll_view(view, steps, redraw);
1406                 return;
1407         }
1408
1409         /* Draw the current line */
1410         draw_view_line(view, view->lineno - view->offset);
1411
1412         if (!redraw)
1413                 return;
1414
1415         redrawwin(view->win);
1416         wrefresh(view->win);
1417         report("");
1418 }
1419
1420
1421 /*
1422  * Incremental updating
1423  */
1424
1425 static void
1426 end_update(struct view *view)
1427 {
1428         if (!view->pipe)
1429                 return;
1430         set_nonblocking_input(FALSE);
1431         if (view->pipe == stdin)
1432                 fclose(view->pipe);
1433         else
1434                 pclose(view->pipe);
1435         view->pipe = NULL;
1436 }
1437
1438 static bool
1439 begin_update(struct view *view)
1440 {
1441         const char *id = view->id;
1442
1443         if (view->pipe)
1444                 end_update(view);
1445
1446         if (opt_cmd[0]) {
1447                 string_copy(view->cmd, opt_cmd);
1448                 opt_cmd[0] = 0;
1449                 /* When running random commands, the view ref could have become
1450                  * invalid so clear it. */
1451                 view->ref[0] = 0;
1452         } else {
1453                 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
1454
1455                 if (snprintf(view->cmd, sizeof(view->cmd), format,
1456                              id, id, id, id, id) >= sizeof(view->cmd))
1457                         return FALSE;
1458         }
1459
1460         /* Special case for the pager view. */
1461         if (opt_pipe) {
1462                 view->pipe = opt_pipe;
1463                 opt_pipe = NULL;
1464         } else {
1465                 view->pipe = popen(view->cmd, "r");
1466         }
1467
1468         if (!view->pipe)
1469                 return FALSE;
1470
1471         set_nonblocking_input(TRUE);
1472
1473         view->offset = 0;
1474         view->lines  = 0;
1475         view->lineno = 0;
1476         string_copy(view->vid, id);
1477
1478         if (view->line) {
1479                 int i;
1480
1481                 for (i = 0; i < view->lines; i++)
1482                         if (view->line[i].data)
1483                                 free(view->line[i].data);
1484
1485                 free(view->line);
1486                 view->line = NULL;
1487         }
1488
1489         view->start_time = time(NULL);
1490
1491         return TRUE;
1492 }
1493
1494 static bool
1495 update_view(struct view *view)
1496 {
1497         char buffer[BUFSIZ];
1498         char *line;
1499         struct line *tmp;
1500         /* The number of lines to read. If too low it will cause too much
1501          * redrawing (and possible flickering), if too high responsiveness
1502          * will suffer. */
1503         unsigned long lines = view->height;
1504         int redraw_from = -1;
1505
1506         if (!view->pipe)
1507                 return TRUE;
1508
1509         /* Only redraw if lines are visible. */
1510         if (view->offset + view->height >= view->lines)
1511                 redraw_from = view->lines - view->offset;
1512
1513         tmp = realloc(view->line, sizeof(*view->line) * (view->lines + lines));
1514         if (!tmp)
1515                 goto alloc_error;
1516
1517         view->line = tmp;
1518
1519         while ((line = fgets(buffer, sizeof(buffer), view->pipe))) {
1520                 int linelen = strlen(line);
1521
1522                 struct line *prev = view->lines
1523                                   ? &view->line[view->lines - 1]
1524                                   : NULL;
1525
1526                 if (linelen)
1527                         line[linelen - 1] = 0;
1528
1529                 if (!view->ops->read(view, prev, line))
1530                         goto alloc_error;
1531
1532                 if (lines-- == 1)
1533                         break;
1534         }
1535
1536         {
1537                 int digits;
1538
1539                 lines = view->lines;
1540                 for (digits = 0; lines; digits++)
1541                         lines /= 10;
1542
1543                 /* Keep the displayed view in sync with line number scaling. */
1544                 if (digits != view->digits) {
1545                         view->digits = digits;
1546                         redraw_from = 0;
1547                 }
1548         }
1549
1550         if (redraw_from >= 0) {
1551                 /* If this is an incremental update, redraw the previous line
1552                  * since for commits some members could have changed when
1553                  * loading the main view. */
1554                 if (redraw_from > 0)
1555                         redraw_from--;
1556
1557                 /* Incrementally draw avoids flickering. */
1558                 redraw_view_from(view, redraw_from);
1559         }
1560
1561         /* Update the title _after_ the redraw so that if the redraw picks up a
1562          * commit reference in view->ref it'll be available here. */
1563         update_view_title(view);
1564
1565         if (ferror(view->pipe)) {
1566                 report("Failed to read: %s", strerror(errno));
1567                 goto end;
1568
1569         } else if (feof(view->pipe)) {
1570                 if (view == VIEW(REQ_VIEW_HELP)) {
1571                         const char *msg = TIG_HELP;
1572
1573                         if (view->lines == 0) {
1574                                 /* Slightly ugly, but abusing view->ref keeps
1575                                  * the error message. */
1576                                 string_copy(view->ref, "No help available");
1577                                 msg = "The tig(1) manpage is not installed";
1578                         }
1579
1580                         report("%s", msg);
1581                         goto end;
1582                 }
1583
1584                 report("");
1585                 goto end;
1586         }
1587
1588         return TRUE;
1589
1590 alloc_error:
1591         report("Allocation failure");
1592
1593 end:
1594         end_update(view);
1595         return FALSE;
1596 }
1597
1598 enum open_flags {
1599         OPEN_DEFAULT = 0,       /* Use default view switching. */
1600         OPEN_SPLIT = 1,         /* Split current view. */
1601         OPEN_BACKGROUNDED = 2,  /* Backgrounded. */
1602         OPEN_RELOAD = 4,        /* Reload view even if it is the current. */
1603 };
1604
1605 static void
1606 open_view(struct view *prev, enum request request, enum open_flags flags)
1607 {
1608         bool backgrounded = !!(flags & OPEN_BACKGROUNDED);
1609         bool split = !!(flags & OPEN_SPLIT);
1610         bool reload = !!(flags & OPEN_RELOAD);
1611         struct view *view = VIEW(request);
1612         int nviews = displayed_views();
1613         struct view *base_view = display[0];
1614
1615         if (view == prev && nviews == 1 && !reload) {
1616                 report("Already in %s view", view->name);
1617                 return;
1618         }
1619
1620         if ((reload || strcmp(view->vid, view->id)) &&
1621             !begin_update(view)) {
1622                 report("Failed to load %s view", view->name);
1623                 return;
1624         }
1625
1626         if (split) {
1627                 display[current_view + 1] = view;
1628                 if (!backgrounded)
1629                         current_view++;
1630         } else {
1631                 /* Maximize the current view. */
1632                 memset(display, 0, sizeof(display));
1633                 current_view = 0;
1634                 display[current_view] = view;
1635         }
1636
1637         /* Resize the view when switching between split- and full-screen,
1638          * or when switching between two different full-screen views. */
1639         if (nviews != displayed_views() ||
1640             (nviews == 1 && base_view != display[0]))
1641                 resize_display();
1642
1643         if (split && prev->lineno - prev->offset >= prev->height) {
1644                 /* Take the title line into account. */
1645                 int lines = prev->lineno - prev->offset - prev->height + 1;
1646
1647                 /* Scroll the view that was split if the current line is
1648                  * outside the new limited view. */
1649                 do_scroll_view(prev, lines, TRUE);
1650         }
1651
1652         if (prev && view != prev) {
1653                 if (split && !backgrounded) {
1654                         /* "Blur" the previous view. */
1655                         update_view_title(prev);
1656                 }
1657
1658                 view->parent = prev;
1659         }
1660
1661         if (view->pipe && view->lines == 0) {
1662                 /* Clear the old view and let the incremental updating refill
1663                  * the screen. */
1664                 wclear(view->win);
1665                 report("");
1666         } else {
1667                 redraw_view(view);
1668                 if (view == VIEW(REQ_VIEW_HELP))
1669                         report("%s", TIG_HELP);
1670                 else
1671                         report("");
1672         }
1673
1674         /* If the view is backgrounded the above calls to report()
1675          * won't redraw the view title. */
1676         if (backgrounded)
1677                 update_view_title(view);
1678 }
1679
1680
1681 /*
1682  * User request switch noodle
1683  */
1684
1685 static int
1686 view_driver(struct view *view, enum request request)
1687 {
1688         int i;
1689
1690         switch (request) {
1691         case REQ_MOVE_UP:
1692         case REQ_MOVE_DOWN:
1693         case REQ_MOVE_PAGE_UP:
1694         case REQ_MOVE_PAGE_DOWN:
1695         case REQ_MOVE_FIRST_LINE:
1696         case REQ_MOVE_LAST_LINE:
1697                 move_view(view, request, TRUE);
1698                 break;
1699
1700         case REQ_SCROLL_LINE_DOWN:
1701         case REQ_SCROLL_LINE_UP:
1702         case REQ_SCROLL_PAGE_DOWN:
1703         case REQ_SCROLL_PAGE_UP:
1704                 scroll_view(view, request);
1705                 break;
1706
1707         case REQ_VIEW_MAIN:
1708         case REQ_VIEW_DIFF:
1709         case REQ_VIEW_LOG:
1710         case REQ_VIEW_HELP:
1711         case REQ_VIEW_PAGER:
1712                 open_view(view, request, OPEN_DEFAULT);
1713                 break;
1714
1715         case REQ_NEXT:
1716         case REQ_PREVIOUS:
1717                 request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
1718
1719                 if (view == VIEW(REQ_VIEW_DIFF) &&
1720                     view->parent == VIEW(REQ_VIEW_MAIN)) {
1721                         bool redraw = display[1] == view;
1722
1723                         view = view->parent;
1724                         move_view(view, request, redraw);
1725                         if (redraw)
1726                                 update_view_title(view);
1727                 } else {
1728                         move_view(view, request, TRUE);
1729                         break;
1730                 }
1731                 /* Fall-through */
1732
1733         case REQ_ENTER:
1734                 if (!view->lines) {
1735                         report("Nothing to enter");
1736                         break;
1737                 }
1738                 return view->ops->enter(view, &view->line[view->lineno]);
1739
1740         case REQ_VIEW_NEXT:
1741         {
1742                 int nviews = displayed_views();
1743                 int next_view = (current_view + 1) % nviews;
1744
1745                 if (next_view == current_view) {
1746                         report("Only one view is displayed");
1747                         break;
1748                 }
1749
1750                 current_view = next_view;
1751                 /* Blur out the title of the previous view. */
1752                 update_view_title(view);
1753                 report("");
1754                 break;
1755         }
1756         case REQ_TOGGLE_LINE_NUMBERS:
1757                 opt_line_number = !opt_line_number;
1758                 redraw_display();
1759                 break;
1760
1761         case REQ_PROMPT:
1762                 /* Always reload^Wrerun commands from the prompt. */
1763                 open_view(view, opt_request, OPEN_RELOAD);
1764                 break;
1765
1766         case REQ_STOP_LOADING:
1767                 for (i = 0; i < ARRAY_SIZE(views); i++) {
1768                         view = &views[i];
1769                         if (view->pipe)
1770                                 report("Stopped loading the %s view", view->name),
1771                         end_update(view);
1772                 }
1773                 break;
1774
1775         case REQ_SHOW_VERSION:
1776                 report("%s (built %s)", VERSION, __DATE__);
1777                 return TRUE;
1778
1779         case REQ_SCREEN_RESIZE:
1780                 resize_display();
1781                 /* Fall-through */
1782         case REQ_SCREEN_REDRAW:
1783                 redraw_display();
1784                 break;
1785
1786         case REQ_SCREEN_UPDATE:
1787                 doupdate();
1788                 return TRUE;
1789
1790         case REQ_VIEW_CLOSE:
1791                 /* XXX: Mark closed views by letting view->parent point to the
1792                  * view itself. Parents to closed view should never be
1793                  * followed. */
1794                 if (view->parent &&
1795                     view->parent->parent != view->parent) {
1796                         memset(display, 0, sizeof(display));
1797                         current_view = 0;
1798                         display[current_view] = view->parent;
1799                         view->parent = view;
1800                         resize_display();
1801                         redraw_display();
1802                         break;
1803                 }
1804                 /* Fall-through */
1805         case REQ_QUIT:
1806                 return FALSE;
1807
1808         default:
1809                 /* An unknown key will show most commonly used commands. */
1810                 report("Unknown key, press 'h' for help");
1811                 return TRUE;
1812         }
1813
1814         return TRUE;
1815 }
1816
1817
1818 /*
1819  * Pager backend
1820  */
1821
1822 static bool
1823 pager_draw(struct view *view, struct line *line, unsigned int lineno)
1824 {
1825         char *text = line->data;
1826         enum line_type type = line->type;
1827         int textlen = strlen(text);
1828         int attr;
1829
1830         wmove(view->win, lineno, 0);
1831
1832         if (view->offset + lineno == view->lineno) {
1833                 if (type == LINE_COMMIT) {
1834                         string_copy(view->ref, text + 7);
1835                         string_copy(ref_commit, view->ref);
1836                 }
1837
1838                 type = LINE_CURSOR;
1839                 wchgat(view->win, -1, 0, type, NULL);
1840         }
1841
1842         attr = get_line_attr(type);
1843         wattrset(view->win, attr);
1844
1845         if (opt_line_number || opt_tab_size < TABSIZE) {
1846                 static char spaces[] = "                    ";
1847                 int col_offset = 0, col = 0;
1848
1849                 if (opt_line_number) {
1850                         unsigned long real_lineno = view->offset + lineno + 1;
1851
1852                         if (real_lineno == 1 ||
1853                             (real_lineno % opt_num_interval) == 0) {
1854                                 wprintw(view->win, "%.*d", view->digits, real_lineno);
1855
1856                         } else {
1857                                 waddnstr(view->win, spaces,
1858                                          MIN(view->digits, STRING_SIZE(spaces)));
1859                         }
1860                         waddstr(view->win, ": ");
1861                         col_offset = view->digits + 2;
1862                 }
1863
1864                 while (text && col_offset + col < view->width) {
1865                         int cols_max = view->width - col_offset - col;
1866                         char *pos = text;
1867                         int cols;
1868
1869                         if (*text == '\t') {
1870                                 text++;
1871                                 assert(sizeof(spaces) > TABSIZE);
1872                                 pos = spaces;
1873                                 cols = opt_tab_size - (col % opt_tab_size);
1874
1875                         } else {
1876                                 text = strchr(text, '\t');
1877                                 cols = line ? text - pos : strlen(pos);
1878                         }
1879
1880                         waddnstr(view->win, pos, MIN(cols, cols_max));
1881                         col += cols;
1882                 }
1883
1884         } else {
1885                 int col = 0, pos = 0;
1886
1887                 for (; pos < textlen && col < view->width; pos++, col++)
1888                         if (text[pos] == '\t')
1889                                 col += TABSIZE - (col % TABSIZE) - 1;
1890
1891                 waddnstr(view->win, text, pos);
1892         }
1893
1894         return TRUE;
1895 }
1896
1897 static bool
1898 pager_read(struct view *view, struct line *prev, char *line)
1899 {
1900         /* Compress empty lines in the help view. */
1901         if (view == VIEW(REQ_VIEW_HELP) &&
1902             !*line && prev && !*((char *) prev->data))
1903                 return TRUE;
1904
1905         view->line[view->lines].data = strdup(line);
1906         if (!view->line[view->lines].data)
1907                 return FALSE;
1908
1909         view->line[view->lines].type = get_line_type(line);
1910
1911         view->lines++;
1912         return TRUE;
1913 }
1914
1915 static bool
1916 pager_enter(struct view *view, struct line *line)
1917 {
1918         int split = 0;
1919
1920         if (line->type == LINE_COMMIT &&
1921            (view == VIEW(REQ_VIEW_LOG) ||
1922             view == VIEW(REQ_VIEW_PAGER))) {
1923                 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
1924                 split = 1;
1925         }
1926
1927         /* Always scroll the view even if it was split. That way
1928          * you can use Enter to scroll through the log view and
1929          * split open each commit diff. */
1930         scroll_view(view, REQ_SCROLL_LINE_DOWN);
1931
1932         /* FIXME: A minor workaround. Scrolling the view will call report("")
1933          * but if we are scrolling a non-current view this won't properly
1934          * update the view title. */
1935         if (split)
1936                 update_view_title(view);
1937
1938         return TRUE;
1939 }
1940
1941 static struct view_ops pager_ops = {
1942         "line",
1943         pager_draw,
1944         pager_read,
1945         pager_enter,
1946 };
1947
1948
1949 /*
1950  * Main view backend
1951  */
1952
1953 struct commit {
1954         char id[41];            /* SHA1 ID. */
1955         char title[75];         /* The first line of the commit message. */
1956         char author[75];        /* The author of the commit. */
1957         struct tm time;         /* Date from the author ident. */
1958         struct ref **refs;      /* Repository references; tags & branch heads. */
1959 };
1960
1961 static bool
1962 main_draw(struct view *view, struct line *line, unsigned int lineno)
1963 {
1964         char buf[DATE_COLS + 1];
1965         struct commit *commit = line->data;
1966         enum line_type type;
1967         int col = 0;
1968         size_t timelen;
1969         size_t authorlen;
1970         int trimmed = 1;
1971
1972         if (!*commit->author)
1973                 return FALSE;
1974
1975         wmove(view->win, lineno, col);
1976
1977         if (view->offset + lineno == view->lineno) {
1978                 string_copy(view->ref, commit->id);
1979                 string_copy(ref_commit, view->ref);
1980                 type = LINE_CURSOR;
1981                 wattrset(view->win, get_line_attr(type));
1982                 wchgat(view->win, -1, 0, type, NULL);
1983
1984         } else {
1985                 type = LINE_MAIN_COMMIT;
1986                 wattrset(view->win, get_line_attr(LINE_MAIN_DATE));
1987         }
1988
1989         timelen = strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time);
1990         waddnstr(view->win, buf, timelen);
1991         waddstr(view->win, " ");
1992
1993         col += DATE_COLS;
1994         wmove(view->win, lineno, col);
1995         if (type != LINE_CURSOR)
1996                 wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
1997
1998         if (opt_utf8) {
1999                 authorlen = utf8_length(commit->author, AUTHOR_COLS - 2, &col, &trimmed);
2000         } else {
2001                 authorlen = strlen(commit->author);
2002                 if (authorlen > AUTHOR_COLS - 2) {
2003                         authorlen = AUTHOR_COLS - 2;
2004                         trimmed = 1;
2005                 }
2006         }
2007
2008         if (trimmed) {
2009                 waddnstr(view->win, commit->author, authorlen);
2010                 if (type != LINE_CURSOR)
2011                         wattrset(view->win, get_line_attr(LINE_MAIN_DELIM));
2012                 waddch(view->win, '~');
2013         } else {
2014                 waddstr(view->win, commit->author);
2015         }
2016
2017         col += AUTHOR_COLS;
2018         if (type != LINE_CURSOR)
2019                 wattrset(view->win, A_NORMAL);
2020
2021         mvwaddch(view->win, lineno, col, ACS_LTEE);
2022         wmove(view->win, lineno, col + 2);
2023         col += 2;
2024
2025         if (commit->refs) {
2026                 size_t i = 0;
2027
2028                 do {
2029                         if (type == LINE_CURSOR)
2030                                 ;
2031                         else if (commit->refs[i]->tag)
2032                                 wattrset(view->win, get_line_attr(LINE_MAIN_TAG));
2033                         else
2034                                 wattrset(view->win, get_line_attr(LINE_MAIN_REF));
2035                         waddstr(view->win, "[");
2036                         waddstr(view->win, commit->refs[i]->name);
2037                         waddstr(view->win, "]");
2038                         if (type != LINE_CURSOR)
2039                                 wattrset(view->win, A_NORMAL);
2040                         waddstr(view->win, " ");
2041                         col += strlen(commit->refs[i]->name) + STRING_SIZE("[] ");
2042                 } while (commit->refs[i++]->next);
2043         }
2044
2045         if (type != LINE_CURSOR)
2046                 wattrset(view->win, get_line_attr(type));
2047
2048         {
2049                 int titlelen = strlen(commit->title);
2050
2051                 if (col + titlelen > view->width)
2052                         titlelen = view->width - col;
2053
2054                 waddnstr(view->win, commit->title, titlelen);
2055         }
2056
2057         return TRUE;
2058 }
2059
2060 /* Reads git log --pretty=raw output and parses it into the commit struct. */
2061 static bool
2062 main_read(struct view *view, struct line *prev, char *line)
2063 {
2064         enum line_type type = get_line_type(line);
2065         struct commit *commit;
2066
2067         switch (type) {
2068         case LINE_COMMIT:
2069                 commit = calloc(1, sizeof(struct commit));
2070                 if (!commit)
2071                         return FALSE;
2072
2073                 line += STRING_SIZE("commit ");
2074
2075                 view->line[view->lines++].data = commit;
2076                 string_copy(commit->id, line);
2077                 commit->refs = get_refs(commit->id);
2078                 break;
2079
2080         case LINE_AUTHOR:
2081         {
2082                 char *ident = line + STRING_SIZE("author ");
2083                 char *end = strchr(ident, '<');
2084
2085                 if (!prev)
2086                         break;
2087
2088                 commit = prev->data;
2089
2090                 if (end) {
2091                         for (; end > ident && isspace(end[-1]); end--) ;
2092                         *end = 0;
2093                 }
2094
2095                 string_copy(commit->author, ident);
2096
2097                 /* Parse epoch and timezone */
2098                 if (end) {
2099                         char *secs = strchr(end + 1, '>');
2100                         char *zone;
2101                         time_t time;
2102
2103                         if (!secs || secs[1] != ' ')
2104                                 break;
2105
2106                         secs += 2;
2107                         time = (time_t) atol(secs);
2108                         zone = strchr(secs, ' ');
2109                         if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
2110                                 long tz;
2111
2112                                 zone++;
2113                                 tz  = ('0' - zone[1]) * 60 * 60 * 10;
2114                                 tz += ('0' - zone[2]) * 60 * 60;
2115                                 tz += ('0' - zone[3]) * 60;
2116                                 tz += ('0' - zone[4]) * 60;
2117
2118                                 if (zone[0] == '-')
2119                                         tz = -tz;
2120
2121                                 time -= tz;
2122                         }
2123                         gmtime_r(&time, &commit->time);
2124                 }
2125                 break;
2126         }
2127         default:
2128                 if (!prev)
2129                         break;
2130
2131                 commit = prev->data;
2132
2133                 /* Fill in the commit title if it has not already been set. */
2134                 if (commit->title[0])
2135                         break;
2136
2137                 /* Require titles to start with a non-space character at the
2138                  * offset used by git log. */
2139                 /* FIXME: More gracefull handling of titles; append "..." to
2140                  * shortened titles, etc. */
2141                 if (strncmp(line, "    ", 4) ||
2142                     isspace(line[4]))
2143                         break;
2144
2145                 string_copy(commit->title, line + 4);
2146         }
2147
2148         return TRUE;
2149 }
2150
2151 static bool
2152 main_enter(struct view *view, struct line *line)
2153 {
2154         enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
2155
2156         open_view(view, REQ_VIEW_DIFF, flags);
2157         return TRUE;
2158 }
2159
2160 static struct view_ops main_ops = {
2161         "commit",
2162         main_draw,
2163         main_read,
2164         main_enter,
2165 };
2166
2167
2168 /**
2169  * KEYS
2170  * ----
2171  * Below the default key bindings are shown.
2172  **/
2173
2174 struct keymap {
2175         int alias;
2176         int request;
2177 };
2178
2179 static struct keymap keymap[] = {
2180         /**
2181          * View switching
2182          * ~~~~~~~~~~~~~~
2183          * m::
2184          *      Switch to main view.
2185          * d::
2186          *      Switch to diff view.
2187          * l::
2188          *      Switch to log view.
2189          * p::
2190          *      Switch to pager view.
2191          * h::
2192          *      Show man page.
2193          **/
2194         { 'm',          REQ_VIEW_MAIN },
2195         { 'd',          REQ_VIEW_DIFF },
2196         { 'l',          REQ_VIEW_LOG },
2197         { 'p',          REQ_VIEW_PAGER },
2198         { 'h',          REQ_VIEW_HELP },
2199
2200         /**
2201          * View manipulation
2202          * ~~~~~~~~~~~~~~~~~
2203          * q::
2204          *      Close view, if multiple views are open it will jump back to the
2205          *      previous view in the view stack. If it is the last open view it
2206          *      will quit. Use 'Q' to quit all views at once.
2207          * Enter::
2208          *      This key is "context sensitive" depending on what view you are
2209          *      currently in. When in log view on a commit line or in the main
2210          *      view, split the view and show the commit diff. In the diff view
2211          *      pressing Enter will simply scroll the view one line down.
2212          * Tab::
2213          *      Switch to next view.
2214          * Up::
2215          *      This key is "context sensitive" and will move the cursor one
2216          *      line up. However, uf you opened a diff view from the main view
2217          *      (split- or full-screen) it will change the cursor to point to
2218          *      the previous commit in the main view and update the diff view
2219          *      to display it.
2220          * Down::
2221          *      Similar to 'Up' but will move down.
2222          **/
2223         { 'q',          REQ_VIEW_CLOSE },
2224         { KEY_TAB,      REQ_VIEW_NEXT },
2225         { KEY_RETURN,   REQ_ENTER },
2226         { KEY_UP,       REQ_PREVIOUS },
2227         { KEY_DOWN,     REQ_NEXT },
2228
2229         /**
2230          * Cursor navigation
2231          * ~~~~~~~~~~~~~~~~~
2232          * j::
2233          *      Move cursor one line up.
2234          * k::
2235          *      Move cursor one line down.
2236          * PgUp::
2237          * b::
2238          * -::
2239          *      Move cursor one page up.
2240          * PgDown::
2241          * Space::
2242          *      Move cursor one page down.
2243          * Home::
2244          *      Jump to first line.
2245          * End::
2246          *      Jump to last line.
2247          **/
2248         { 'k',          REQ_MOVE_UP },
2249         { 'j',          REQ_MOVE_DOWN },
2250         { KEY_HOME,     REQ_MOVE_FIRST_LINE },
2251         { KEY_END,      REQ_MOVE_LAST_LINE },
2252         { KEY_NPAGE,    REQ_MOVE_PAGE_DOWN },
2253         { ' ',          REQ_MOVE_PAGE_DOWN },
2254         { KEY_PPAGE,    REQ_MOVE_PAGE_UP },
2255         { 'b',          REQ_MOVE_PAGE_UP },
2256         { '-',          REQ_MOVE_PAGE_UP },
2257
2258         /**
2259          * Scrolling
2260          * ~~~~~~~~~
2261          * Insert::
2262          *      Scroll view one line up.
2263          * Delete::
2264          *      Scroll view one line down.
2265          * w::
2266          *      Scroll view one page up.
2267          * s::
2268          *      Scroll view one page down.
2269          **/
2270         { KEY_IC,       REQ_SCROLL_LINE_UP },
2271         { KEY_DC,       REQ_SCROLL_LINE_DOWN },
2272         { 'w',          REQ_SCROLL_PAGE_UP },
2273         { 's',          REQ_SCROLL_PAGE_DOWN },
2274
2275         /**
2276          * Misc
2277          * ~~~~
2278          * Q::
2279          *      Quit.
2280          * r::
2281          *      Redraw screen.
2282          * z::
2283          *      Stop all background loading. This can be useful if you use
2284          *      tig(1) in a repository with a long history without limiting
2285          *      the revision log.
2286          * v::
2287          *      Show version.
2288          * n::
2289          *      Toggle line numbers on/off.
2290          * ':'::
2291          *      Open prompt. This allows you to specify what git command
2292          *      to run. Example:
2293          *
2294          *      :log -p
2295          **/
2296         { 'Q',          REQ_QUIT },
2297         { 'z',          REQ_STOP_LOADING },
2298         { 'v',          REQ_SHOW_VERSION },
2299         { 'r',          REQ_SCREEN_REDRAW },
2300         { 'n',          REQ_TOGGLE_LINE_NUMBERS },
2301         { ':',          REQ_PROMPT },
2302
2303         /* wgetch() with nodelay() enabled returns ERR when there's no input. */
2304         { ERR,          REQ_SCREEN_UPDATE },
2305
2306         /* Use the ncurses SIGWINCH handler. */
2307         { KEY_RESIZE,   REQ_SCREEN_RESIZE },
2308 };
2309
2310 static enum request
2311 get_request(int key)
2312 {
2313         int i;
2314
2315         for (i = 0; i < ARRAY_SIZE(keymap); i++)
2316                 if (keymap[i].alias == key)
2317                         return keymap[i].request;
2318
2319         return (enum request) key;
2320 }
2321
2322
2323 /*
2324  * Unicode / UTF-8 handling
2325  *
2326  * NOTE: Much of the following code for dealing with unicode is derived from
2327  * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
2328  * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
2329  */
2330
2331 /* I've (over)annotated a lot of code snippets because I am not entirely
2332  * confident that the approach taken by this small UTF-8 interface is correct.
2333  * --jonas */
2334
2335 static inline int
2336 unicode_width(unsigned long c)
2337 {
2338         if (c >= 0x1100 &&
2339            (c <= 0x115f                         /* Hangul Jamo */
2340             || c == 0x2329
2341             || c == 0x232a
2342             || (c >= 0x2e80  && c <= 0xa4cf && c != 0x303f)
2343                                                 /* CJK ... Yi */
2344             || (c >= 0xac00  && c <= 0xd7a3)    /* Hangul Syllables */
2345             || (c >= 0xf900  && c <= 0xfaff)    /* CJK Compatibility Ideographs */
2346             || (c >= 0xfe30  && c <= 0xfe6f)    /* CJK Compatibility Forms */
2347             || (c >= 0xff00  && c <= 0xff60)    /* Fullwidth Forms */
2348             || (c >= 0xffe0  && c <= 0xffe6)
2349             || (c >= 0x20000 && c <= 0x2fffd)
2350             || (c >= 0x30000 && c <= 0x3fffd)))
2351                 return 2;
2352
2353         return 1;
2354 }
2355
2356 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
2357  * Illegal bytes are set one. */
2358 static const unsigned char utf8_bytes[256] = {
2359         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,
2360         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,
2361         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,
2362         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,
2363         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,
2364         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,
2365         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,
2366         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,
2367 };
2368
2369 /* Decode UTF-8 multi-byte representation into a unicode character. */
2370 static inline unsigned long
2371 utf8_to_unicode(const char *string, size_t length)
2372 {
2373         unsigned long unicode;
2374
2375         switch (length) {
2376         case 1:
2377                 unicode  =   string[0];
2378                 break;
2379         case 2:
2380                 unicode  =  (string[0] & 0x1f) << 6;
2381                 unicode +=  (string[1] & 0x3f);
2382                 break;
2383         case 3:
2384                 unicode  =  (string[0] & 0x0f) << 12;
2385                 unicode += ((string[1] & 0x3f) << 6);
2386                 unicode +=  (string[2] & 0x3f);
2387                 break;
2388         case 4:
2389                 unicode  =  (string[0] & 0x0f) << 18;
2390                 unicode += ((string[1] & 0x3f) << 12);
2391                 unicode += ((string[2] & 0x3f) << 6);
2392                 unicode +=  (string[3] & 0x3f);
2393                 break;
2394         case 5:
2395                 unicode  =  (string[0] & 0x0f) << 24;
2396                 unicode += ((string[1] & 0x3f) << 18);
2397                 unicode += ((string[2] & 0x3f) << 12);
2398                 unicode += ((string[3] & 0x3f) << 6);
2399                 unicode +=  (string[4] & 0x3f);
2400                 break;
2401         case 6:
2402                 unicode  =  (string[0] & 0x01) << 30;
2403                 unicode += ((string[1] & 0x3f) << 24);
2404                 unicode += ((string[2] & 0x3f) << 18);
2405                 unicode += ((string[3] & 0x3f) << 12);
2406                 unicode += ((string[4] & 0x3f) << 6);
2407                 unicode +=  (string[5] & 0x3f);
2408                 break;
2409         default:
2410                 die("Invalid unicode length");
2411         }
2412
2413         /* Invalid characters could return the special 0xfffd value but NUL
2414          * should be just as good. */
2415         return unicode > 0xffff ? 0 : unicode;
2416 }
2417
2418 /* Calculates how much of string can be shown within the given maximum width
2419  * and sets trimmed parameter to non-zero value if all of string could not be
2420  * shown.
2421  *
2422  * Additionally, adds to coloffset how many many columns to move to align with
2423  * the expected position. Takes into account how multi-byte and double-width
2424  * characters will effect the cursor position.
2425  *
2426  * Returns the number of bytes to output from string to satisfy max_width. */
2427 static size_t
2428 utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed)
2429 {
2430         const char *start = string;
2431         const char *end = strchr(string, '\0');
2432         size_t mbwidth = 0;
2433         size_t width = 0;
2434
2435         *trimmed = 0;
2436
2437         while (string < end) {
2438                 int c = *(unsigned char *) string;
2439                 unsigned char bytes = utf8_bytes[c];
2440                 size_t ucwidth;
2441                 unsigned long unicode;
2442
2443                 if (string + bytes > end)
2444                         break;
2445
2446                 /* Change representation to figure out whether
2447                  * it is a single- or double-width character. */
2448
2449                 unicode = utf8_to_unicode(string, bytes);
2450                 /* FIXME: Graceful handling of invalid unicode character. */
2451                 if (!unicode)
2452                         break;
2453
2454                 ucwidth = unicode_width(unicode);
2455                 width  += ucwidth;
2456                 if (width > max_width) {
2457                         *trimmed = 1;
2458                         break;
2459                 }
2460
2461                 /* The column offset collects the differences between the
2462                  * number of bytes encoding a character and the number of
2463                  * columns will be used for rendering said character.
2464                  *
2465                  * So if some character A is encoded in 2 bytes, but will be
2466                  * represented on the screen using only 1 byte this will and up
2467                  * adding 1 to the multi-byte column offset.
2468                  *
2469                  * Assumes that no double-width character can be encoding in
2470                  * less than two bytes. */
2471                 if (bytes > ucwidth)
2472                         mbwidth += bytes - ucwidth;
2473
2474                 string  += bytes;
2475         }
2476
2477         *coloffset += mbwidth;
2478
2479         return string - start;
2480 }
2481
2482
2483 /*
2484  * Status management
2485  */
2486
2487 /* Whether or not the curses interface has been initialized. */
2488 static bool cursed = FALSE;
2489
2490 /* The status window is used for polling keystrokes. */
2491 static WINDOW *status_win;
2492
2493 /* Update status and title window. */
2494 static void
2495 report(const char *msg, ...)
2496 {
2497         static bool empty = TRUE;
2498         struct view *view = display[current_view];
2499
2500         if (!empty || *msg) {
2501                 va_list args;
2502
2503                 va_start(args, msg);
2504
2505                 werase(status_win);
2506                 wmove(status_win, 0, 0);
2507                 if (*msg) {
2508                         vwprintw(status_win, msg, args);
2509                         empty = FALSE;
2510                 } else {
2511                         empty = TRUE;
2512                 }
2513                 wrefresh(status_win);
2514
2515                 va_end(args);
2516         }
2517
2518         update_view_title(view);
2519         update_display_cursor();
2520 }
2521
2522 /* Controls when nodelay should be in effect when polling user input. */
2523 static void
2524 set_nonblocking_input(bool loading)
2525 {
2526         static unsigned int loading_views;
2527
2528         if ((loading == FALSE && loading_views-- == 1) ||
2529             (loading == TRUE  && loading_views++ == 0))
2530                 nodelay(status_win, loading);
2531 }
2532
2533 static void
2534 init_display(void)
2535 {
2536         int x, y;
2537
2538         /* Initialize the curses library */
2539         if (isatty(STDIN_FILENO)) {
2540                 cursed = !!initscr();
2541         } else {
2542                 /* Leave stdin and stdout alone when acting as a pager. */
2543                 FILE *io = fopen("/dev/tty", "r+");
2544
2545                 cursed = !!newterm(NULL, io, io);
2546         }
2547
2548         if (!cursed)
2549                 die("Failed to initialize curses");
2550
2551         nonl();         /* Tell curses not to do NL->CR/NL on output */
2552         cbreak();       /* Take input chars one at a time, no wait for \n */
2553         noecho();       /* Don't echo input */
2554         leaveok(stdscr, TRUE);
2555
2556         if (has_colors())
2557                 init_colors();
2558
2559         getmaxyx(stdscr, y, x);
2560         status_win = newwin(1, 0, y - 1, 0);
2561         if (!status_win)
2562                 die("Failed to create status window");
2563
2564         /* Enable keyboard mapping */
2565         keypad(status_win, TRUE);
2566         wbkgdset(status_win, get_line_attr(LINE_STATUS));
2567 }
2568
2569
2570 /*
2571  * Repository references
2572  */
2573
2574 static struct ref *refs;
2575 static size_t refs_size;
2576
2577 /* Id <-> ref store */
2578 static struct ref ***id_refs;
2579 static size_t id_refs_size;
2580
2581 static struct ref **
2582 get_refs(char *id)
2583 {
2584         struct ref ***tmp_id_refs;
2585         struct ref **ref_list = NULL;
2586         size_t ref_list_size = 0;
2587         size_t i;
2588
2589         for (i = 0; i < id_refs_size; i++)
2590                 if (!strcmp(id, id_refs[i][0]->id))
2591                         return id_refs[i];
2592
2593         tmp_id_refs = realloc(id_refs, (id_refs_size + 1) * sizeof(*id_refs));
2594         if (!tmp_id_refs)
2595                 return NULL;
2596
2597         id_refs = tmp_id_refs;
2598
2599         for (i = 0; i < refs_size; i++) {
2600                 struct ref **tmp;
2601
2602                 if (strcmp(id, refs[i].id))
2603                         continue;
2604
2605                 tmp = realloc(ref_list, (ref_list_size + 1) * sizeof(*ref_list));
2606                 if (!tmp) {
2607                         if (ref_list)
2608                                 free(ref_list);
2609                         return NULL;
2610                 }
2611
2612                 ref_list = tmp;
2613                 if (ref_list_size > 0)
2614                         ref_list[ref_list_size - 1]->next = 1;
2615                 ref_list[ref_list_size] = &refs[i];
2616
2617                 /* XXX: The properties of the commit chains ensures that we can
2618                  * safely modify the shared ref. The repo references will
2619                  * always be similar for the same id. */
2620                 ref_list[ref_list_size]->next = 0;
2621                 ref_list_size++;
2622         }
2623
2624         if (ref_list)
2625                 id_refs[id_refs_size++] = ref_list;
2626
2627         return ref_list;
2628 }
2629
2630 static int
2631 read_ref(char *id, int idlen, char *name, int namelen)
2632 {
2633         struct ref *ref;
2634         bool tag = FALSE;
2635         bool tag_commit = FALSE;
2636
2637         /* Commits referenced by tags has "^{}" appended. */
2638         if (name[namelen - 1] == '}') {
2639                 while (namelen > 0 && name[namelen] != '^')
2640                         namelen--;
2641                 if (namelen > 0)
2642                         tag_commit = TRUE;
2643                 name[namelen] = 0;
2644         }
2645
2646         if (!strncmp(name, "refs/tags/", STRING_SIZE("refs/tags/"))) {
2647                 if (!tag_commit)
2648                         return OK;
2649                 name += STRING_SIZE("refs/tags/");
2650                 tag = TRUE;
2651
2652         } else if (!strncmp(name, "refs/heads/", STRING_SIZE("refs/heads/"))) {
2653                 name += STRING_SIZE("refs/heads/");
2654
2655         } else if (!strcmp(name, "HEAD")) {
2656                 return OK;
2657         }
2658
2659         refs = realloc(refs, sizeof(*refs) * (refs_size + 1));
2660         if (!refs)
2661                 return ERR;
2662
2663         ref = &refs[refs_size++];
2664         ref->name = strdup(name);
2665         if (!ref->name)
2666                 return ERR;
2667
2668         ref->tag = tag;
2669         string_copy(ref->id, id);
2670
2671         return OK;
2672 }
2673
2674 static int
2675 load_refs(void)
2676 {
2677         const char *cmd_env = getenv("TIG_LS_REMOTE");
2678         const char *cmd = cmd_env && *cmd_env ? cmd_env : TIG_LS_REMOTE;
2679
2680         return read_properties(popen(cmd, "r"), "\t", read_ref);
2681 }
2682
2683 static int
2684 read_repo_config_option(char *name, int namelen, char *value, int valuelen)
2685 {
2686         if (!strcmp(name, "i18n.commitencoding")) {
2687                 string_copy(opt_encoding, value);
2688         }
2689
2690         return OK;
2691 }
2692
2693 static int
2694 load_repo_config(void)
2695 {
2696         return read_properties(popen("git repo-config --list", "r"),
2697                                "=", read_repo_config_option);
2698 }
2699
2700 static int
2701 read_properties(FILE *pipe, const char *separators,
2702                 int (*read_property)(char *, int, char *, int))
2703 {
2704         char buffer[BUFSIZ];
2705         char *name;
2706         int state = OK;
2707
2708         if (!pipe)
2709                 return ERR;
2710
2711         while (state == OK && (name = fgets(buffer, sizeof(buffer), pipe))) {
2712                 char *value;
2713                 size_t namelen;
2714                 size_t valuelen;
2715
2716                 name = chomp_string(name);
2717                 namelen = strcspn(name, separators);
2718
2719                 if (name[namelen]) {
2720                         name[namelen] = 0;
2721                         value = chomp_string(name + namelen + 1);
2722                         valuelen = strlen(value);
2723
2724                 } else {
2725                         value = "";
2726                         valuelen = 0;
2727                 }
2728
2729                 if (namelen)
2730                         state = read_property(name, namelen, value, valuelen);
2731         }
2732
2733         if (state != ERR && ferror(pipe))
2734                 state = ERR;
2735
2736         pclose(pipe);
2737
2738         return state;
2739 }
2740
2741
2742 /*
2743  * Main
2744  */
2745
2746 #if __GNUC__ >= 3
2747 #define __NORETURN __attribute__((__noreturn__))
2748 #else
2749 #define __NORETURN
2750 #endif
2751
2752 static void __NORETURN
2753 quit(int sig)
2754 {
2755         /* XXX: Restore tty modes and let the OS cleanup the rest! */
2756         if (cursed)
2757                 endwin();
2758         exit(0);
2759 }
2760
2761 static void __NORETURN
2762 die(const char *err, ...)
2763 {
2764         va_list args;
2765
2766         endwin();
2767
2768         va_start(args, err);
2769         fputs("tig: ", stderr);
2770         vfprintf(stderr, err, args);
2771         fputs("\n", stderr);
2772         va_end(args);
2773
2774         exit(1);
2775 }
2776
2777 int
2778 main(int argc, char *argv[])
2779 {
2780         struct view *view;
2781         enum request request;
2782         size_t i;
2783
2784         signal(SIGINT, quit);
2785
2786         if (load_options() == ERR)
2787                 die("Failed to load user config.");
2788
2789         /* Load the repo config file so options can be overwritten from
2790          * the command line.  */
2791         if (load_repo_config() == ERR)
2792                 die("Failed to load repo config.");
2793
2794         if (!parse_options(argc, argv))
2795                 return 0;
2796
2797         if (load_refs() == ERR)
2798                 die("Failed to load refs.");
2799
2800         /* Require a git repository unless when running in pager mode. */
2801         if (refs_size == 0 && opt_request != REQ_VIEW_PAGER)
2802                 die("Not a git repository");
2803
2804         for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
2805                 view->cmd_env = getenv(view->cmd_env);
2806
2807         request = opt_request;
2808
2809         init_display();
2810
2811         while (view_driver(display[current_view], request)) {
2812                 int key;
2813                 int i;
2814
2815                 foreach_view (view, i)
2816                         update_view(view);
2817
2818                 /* Refresh, accept single keystroke of input */
2819                 key = wgetch(status_win);
2820                 request = get_request(key);
2821
2822                 /* Some low-level request handling. This keeps access to
2823                  * status_win restricted. */
2824                 switch (request) {
2825                 case REQ_PROMPT:
2826                         report(":");
2827                         /* Temporarily switch to line-oriented and echoed
2828                          * input. */
2829                         nocbreak();
2830                         echo();
2831
2832                         if (wgetnstr(status_win, opt_cmd + 4, sizeof(opt_cmd) - 4) == OK) {
2833                                 memcpy(opt_cmd, "git ", 4);
2834                                 opt_request = REQ_VIEW_PAGER;
2835                         } else {
2836                                 report("Prompt interrupted by loading view, "
2837                                        "press 'z' to stop loading views");
2838                                 request = REQ_SCREEN_UPDATE;
2839                         }
2840
2841                         noecho();
2842                         cbreak();
2843                         break;
2844
2845                 case REQ_SCREEN_RESIZE:
2846                 {
2847                         int height, width;
2848
2849                         getmaxyx(stdscr, height, width);
2850
2851                         /* Resize the status view and let the view driver take
2852                          * care of resizing the displayed views. */
2853                         wresize(status_win, 1, width);
2854                         mvwin(status_win, height - 1, 0);
2855                         wrefresh(status_win);
2856                         break;
2857                 }
2858                 default:
2859                         break;
2860                 }
2861         }
2862
2863         quit(0);
2864
2865         return 0;
2866 }
2867
2868 /**
2869  * [[refspec]]
2870  * Revision specification
2871  * ----------------------
2872  * This section describes various ways to specify what revisions to display
2873  * or otherwise limit the view to. tig(1) does not itself parse the described
2874  * revision options so refer to the relevant git man pages for futher
2875  * information. Relevant man pages besides git-log(1) are git-diff(1) and
2876  * git-rev-list(1).
2877  *
2878  * You can tune the interaction with git by making use of the options
2879  * explained in this section. For example, by configuring the environment
2880  * variables described in the  <<history-commands, "History commands">>
2881  * section.
2882  *
2883  * Limit by path name
2884  * ~~~~~~~~~~~~~~~~~~
2885  * If you are interested only in those revisions that made changes to a
2886  * specific file (or even several files) list the files like this:
2887  *
2888  *      $ tig log Makefile README
2889  *
2890  * To avoid ambiguity with repository references such as tag name, be sure
2891  * to separate file names from other git options using "\--". So if you
2892  * have a file named 'master' it will clash with the reference named
2893  * 'master', and thus you will have to use:
2894  *
2895  *      $ tig log -- master
2896  *
2897  * NOTE: For the main view, avoiding ambiguity will in some cases require
2898  * you to specify two "\--" options. The first will make tig(1) stop
2899  * option processing and the latter will be passed to git log.
2900  *
2901  * Limit by date or number
2902  * ~~~~~~~~~~~~~~~~~~~~~~~
2903  * To speed up interaction with git, you can limit the amount of commits
2904  * to show both for the log and main view. Either limit by date using
2905  * e.g. `--since=1.month` or limit by the number of commits using `-n400`.
2906  *
2907  * If you are only interested in changed that happened between two dates
2908  * you can use:
2909  *
2910  *      $ tig -- --after="May 5th" --before="2006-05-16 15:44"
2911  *
2912  * NOTE: If you want to avoid having to quote dates containing spaces you
2913  * can use "." instead, e.g. `--after=May.5th`.
2914  *
2915  * Limiting by commit ranges
2916  * ~~~~~~~~~~~~~~~~~~~~~~~~~
2917  * Alternatively, commits can be limited to a specific range, such as
2918  * "all commits between 'tag-1.0' and 'tag-2.0'". For example:
2919  *
2920  *      $ tig log tag-1.0..tag-2.0
2921  *
2922  * This way of commit limiting makes it trivial to only browse the commits
2923  * which haven't been pushed to a remote branch. Assuming 'origin' is your
2924  * upstream remote branch, using:
2925  *
2926  *      $ tig log origin..HEAD
2927  *
2928  * will list what will be pushed to the remote branch. Optionally, the ending
2929  * 'HEAD' can be left out since it is implied.
2930  *
2931  * Limiting by reachability
2932  * ~~~~~~~~~~~~~~~~~~~~~~~~
2933  * Git interprets the range specifier "tag-1.0..tag-2.0" as
2934  * "all commits reachable from 'tag-2.0' but not from 'tag-1.0'".
2935  * Where reachability refers to what commits are ancestors (or part of the
2936  * history) of the branch or tagged revision in question.
2937  *
2938  * If you prefer to specify which commit to preview in this way use the
2939  * following:
2940  *
2941  *      $ tig log tag-2.0 ^tag-1.0
2942  *
2943  * You can think of '^' as a negation operator. Using this alternate syntax,
2944  * it is possible to further prune commits by specifying multiple branch
2945  * cut offs.
2946  *
2947  * Combining revisions specification
2948  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2949  * Revisions options can to some degree be combined, which makes it possible
2950  * to say "show at most 20 commits from within the last month that changed
2951  * files under the Documentation/ directory."
2952  *
2953  *      $ tig -- --since=1.month -n20 -- Documentation/
2954  *
2955  * Examining all repository references
2956  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2957  * In some cases, it can be useful to query changes across all references
2958  * in a repository. An example is to ask "did any line of development in
2959  * this repository change a particular file within the last week". This
2960  * can be accomplished using:
2961  *
2962  *      $ tig -- --all --since=1.week -- Makefile
2963  *
2964  * BUGS
2965  * ----
2966  * Known bugs and problems:
2967  *
2968  * - In it's current state tig is pretty much UTF-8 only.
2969  *
2970  * - If the screen width is very small the main view can draw
2971  *   outside the current view causing bad wrapping. Same goes
2972  *   for title and status windows.
2973  *
2974  * - The cursor can wrap-around on the last line and cause the
2975  *   window to scroll.
2976  *
2977  * - The prompt doesn't work while loading.
2978  *
2979  * TODO
2980  * ----
2981  * Features that should be explored.
2982  *
2983  * - Searching.
2984  *
2985  * - Locale support.
2986  *
2987  * COPYRIGHT
2988  * ---------
2989  * Copyright (c) 2006 Jonas Fonseca <fonseca@diku.dk>
2990  *
2991  * This program is free software; you can redistribute it and/or modify
2992  * it under the terms of the GNU General Public License as published by
2993  * the Free Software Foundation; either version 2 of the License, or
2994  * (at your option) any later version.
2995  *
2996  * SEE ALSO
2997  * --------
2998  * - link:http://www.kernel.org/pub/software/scm/git/docs/[git(7)],
2999  * - link:http://www.kernel.org/pub/software/scm/cogito/docs/[cogito(7)]
3000  *
3001  * Other git repository browsers:
3002  *
3003  *  - gitk(1)
3004  *  - qgit(1)
3005  *  - gitview(1)
3006  **/