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