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

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