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

   1 /* Copyright (c) 2006 Jonas Fonseca <fonseca@diku.dk>
   2  *
   3  * This program is free software; you can redistribute it and/or
   4  * modify it under the terms of the GNU General Public License as
   5  * published by the Free Software Foundation; either version 2 of
   6  * the License, or (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  */
  13
  14 #ifndef VERSION
  15 #define VERSION "unknown-version"
  16 #endif
  17
  18 #ifndef DEBUG
  19 #define NDEBUG
  20 #endif
  21
  22 #include <assert.h>
  23 #include <errno.h>
  24 #include <ctype.h>
  25 #include <signal.h>
  26 #include <stdarg.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <unistd.h>
  31 #include <time.h>
  32
  33 #include <sys/types.h>
  34 #include <regex.h>
  35
  36 #include <locale.h>
  37 #include <langinfo.h>
  38 #include <iconv.h>
  39
  40 #include <curses.h>
  41
  42 #if __GNUC__ >= 3
  43 #define __NORETURN __attribute__((__noreturn__))
  44 #else
  45 #define __NORETURN
  46 #endif
  47
  48 static void __NORETURN die(const char *err, ...);
  49 static void report(const char *msg, ...);
  50 static int read_properties(FILE *pipe, const char *separators, int (*read)(char *, size_t, char *, size_t));
  51 static void set_nonblocking_input(bool loading);
  52 static size_t utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed);
  53
  54 #define ABS(x)          ((x) >= 0  ? (x) : -(x))
  55 #define MIN(x, y)       ((x) < (y) ? (x) :  (y))
  56
  57 #define ARRAY_SIZE(x)   (sizeof(x) / sizeof(x[0]))
  58 #define STRING_SIZE(x)  (sizeof(x) - 1)
  59
  60 #define SIZEOF_STR      1024    /* Default string size. */
  61 #define SIZEOF_REF      256     /* Size of symbolic or SHA1 ID. */
  62 #define SIZEOF_REV      41      /* Holds a SHA-1 and an ending NUL */
  63
  64 /* Revision graph */
  65
  66 #define REVGRAPH_INIT   'I'
  67 #define REVGRAPH_MERGE  'M'
  68 #define REVGRAPH_BRANCH '+'
  69 #define REVGRAPH_COMMIT '*'
  70 #define REVGRAPH_LINE   '|'
  71
  72 #define SIZEOF_REVGRAPH 19      /* Size of revision ancestry graphics. */
  73
  74 /* This color name can be used to refer to the default term colors. */
  75 #define COLOR_DEFAULT   (-1)
  76
  77 #define ICONV_NONE      ((iconv_t) -1)
  78
  79 /* The format and size of the date column in the main view. */
  80 #define DATE_FORMAT     "%Y-%m-%d %H:%M"
  81 #define DATE_COLS       STRING_SIZE("2006-04-29 14:21 ")
  82
  83 #define AUTHOR_COLS     20
  84
  85 /* The default interval between line numbers. */
  86 #define NUMBER_INTERVAL 1
  87
  88 #define TABSIZE         8
  89
  90 #define SCALE_SPLIT_VIEW(height)        ((height) * 2 / 3)
  91
  92 #define TIG_LS_REMOTE \
  93         "git ls-remote $(git rev-parse --git-dir) 2>/dev/null"
  94
  95 #define TIG_DIFF_CMD \
  96         "git show --root --patch-with-stat --find-copies-harder -B -C %s 2>/dev/null"
  97
  98 #define TIG_LOG_CMD     \
  99         "git log --cc --stat -n100 %s 2>/dev/null"
 100
 101 #define TIG_MAIN_CMD \
 102         "git log --topo-order --pretty=raw %s 2>/dev/null"
 103
 104 #define TIG_TREE_CMD    \
 105         "git ls-tree %s %s"
 106
 107 #define TIG_BLOB_CMD    \
 108         "git cat-file blob %s"
 109
 110 /* XXX: Needs to be defined to the empty string. */
 111 #define TIG_HELP_CMD    ""
 112 #define TIG_PAGER_CMD   ""
 113 #define TIG_STATUS_CMD  ""
 114
 115 /* Some ascii-shorthands fitted into the ncurses namespace. */
 116 #define KEY_TAB         '\t'
 117 #define KEY_RETURN      '\r'
 118 #define KEY_ESC         27
 119
 120
 121 struct ref {
 122         char *name;             /* Ref name; tag or head names are shortened. */
 123         char id[SIZEOF_REV];    /* Commit SHA1 ID */
 124         unsigned int tag:1;     /* Is it a tag? */
 125         unsigned int remote:1;  /* Is it a remote ref? */
 126         unsigned int next:1;    /* For ref lists: are there more refs? */
 127 };
 128
 129 static struct ref **get_refs(char *id);
 130
 131 struct int_map {
 132         const char *name;
 133         int namelen;
 134         int value;
 135 };
 136
 137 static int
 138 set_from_int_map(struct int_map *map, size_t map_size,
 139                  int *value, const char *name, int namelen)
 140 {
 141
 142         int i;
 143
 144         for (i = 0; i < map_size; i++)
 145                 if (namelen == map[i].namelen &&
 146                     !strncasecmp(name, map[i].name, namelen)) {
 147                         *value = map[i].value;
 148                         return OK;
 149                 }
 150
 151         return ERR;
 152 }
 153
 154
 155 /*
 156  * String helpers
 157  */
 158
 159 static inline void
 160 string_ncopy_do(char *dst, size_t dstlen, const char *src, size_t srclen)
 161 {
 162         if (srclen > dstlen - 1)
 163                 srclen = dstlen - 1;
 164
 165         strncpy(dst, src, srclen);
 166         dst[srclen] = 0;
 167 }
 168
 169 /* Shorthands for safely copying into a fixed buffer. */
 170
 171 #define string_copy(dst, src) \
 172         string_ncopy_do(dst, sizeof(dst), src, sizeof(src))
 173
 174 #define string_ncopy(dst, src, srclen) \
 175         string_ncopy_do(dst, sizeof(dst), src, srclen)
 176
 177 #define string_copy_rev(dst, src) \
 178         string_ncopy_do(dst, SIZEOF_REV, src, SIZEOF_REV - 1)
 179
 180 #define string_add(dst, from, src) \
 181         string_ncopy_do(dst + (from), sizeof(dst) - (from), src, sizeof(src))
 182
 183 static char *
 184 chomp_string(char *name)
 185 {
 186         int namelen;
 187
 188         while (isspace(*name))
 189                 name++;
 190
 191         namelen = strlen(name) - 1;
 192         while (namelen > 0 && isspace(name[namelen]))
 193                 name[namelen--] = 0;
 194
 195         return name;
 196 }
 197
 198 static bool
 199 string_nformat(char *buf, size_t bufsize, size_t *bufpos, const char *fmt, ...)
 200 {
 201         va_list args;
 202         size_t pos = bufpos ? *bufpos : 0;
 203
 204         va_start(args, fmt);
 205         pos += vsnprintf(buf + pos, bufsize - pos, fmt, args);
 206         va_end(args);
 207
 208         if (bufpos)
 209                 *bufpos = pos;
 210
 211         return pos >= bufsize ? FALSE : TRUE;
 212 }
 213
 214 #define string_format(buf, fmt, args...) \
 215         string_nformat(buf, sizeof(buf), NULL, fmt, args)
 216
 217 #define string_format_from(buf, from, fmt, args...) \
 218         string_nformat(buf, sizeof(buf), from, fmt, args)
 219
 220 static int
 221 string_enum_compare(const char *str1, const char *str2, int len)
 222 {
 223         size_t i;
 224
 225 #define string_enum_sep(x) ((x) == '-' || (x) == '_' || (x) == '.')
 226
 227         /* Diff-Header == DIFF_HEADER */
 228         for (i = 0; i < len; i++) {
 229                 if (toupper(str1[i]) == toupper(str2[i]))
 230                         continue;
 231
 232                 if (string_enum_sep(str1[i]) &&
 233                     string_enum_sep(str2[i]))
 234                         continue;
 235
 236                 return str1[i] - str2[i];
 237         }
 238
 239         return 0;
 240 }
 241
 242 /* Shell quoting
 243  *
 244  * NOTE: The following is a slightly modified copy of the git project's shell
 245  * quoting routines found in the quote.c file.
 246  *
 247  * Help to copy the thing properly quoted for the shell safety.  any single
 248  * quote is replaced with '\'', any exclamation point is replaced with '\!',
 249  * and the whole thing is enclosed in a
 250  *
 251  * E.g.
 252  *  original     sq_quote     result
 253  *  name     ==> name      ==> 'name'
 254  *  a b      ==> a b       ==> 'a b'
 255  *  a'b      ==> a'\''b    ==> 'a'\''b'
 256  *  a!b      ==> a'\!'b    ==> 'a'\!'b'
 257  */
 258
 259 static size_t
 260 sq_quote(char buf[SIZEOF_STR], size_t bufsize, const char *src)
 261 {
 262         char c;
 263
 264 #define BUFPUT(x) do { if (bufsize < SIZEOF_STR) buf[bufsize++] = (x); } while (0)
 265
 266         BUFPUT('\'');
 267         while ((c = *src++)) {
 268                 if (c == '\'' || c == '!') {
 269                         BUFPUT('\'');
 270                         BUFPUT('\\');
 271                         BUFPUT(c);
 272                         BUFPUT('\'');
 273                 } else {
 274                         BUFPUT(c);
 275                 }
 276         }
 277         BUFPUT('\'');
 278
 279         if (bufsize < SIZEOF_STR)
 280                 buf[bufsize] = 0;
 281
 282         return bufsize;
 283 }
 284
 285
 286 /*
 287  * User requests
 288  */
 289
 290 #define REQ_INFO \
 291         /* XXX: Keep the view request first and in sync with views[]. */ \
 292         REQ_GROUP("View switching") \
 293         REQ_(VIEW_MAIN,         "Show main view"), \
 294         REQ_(VIEW_DIFF,         "Show diff view"), \
 295         REQ_(VIEW_LOG,          "Show log view"), \
 296         REQ_(VIEW_TREE,         "Show tree view"), \
 297         REQ_(VIEW_BLOB,         "Show blob view"), \
 298         REQ_(VIEW_HELP,         "Show help page"), \
 299         REQ_(VIEW_PAGER,        "Show pager view"), \
 300         REQ_(VIEW_STATUS,       "Show status view"), \
 301         \
 302         REQ_GROUP("View manipulation") \
 303         REQ_(ENTER,             "Enter current line and scroll"), \
 304         REQ_(NEXT,              "Move to next"), \
 305         REQ_(PREVIOUS,          "Move to previous"), \
 306         REQ_(VIEW_NEXT,         "Move focus to next view"), \
 307         REQ_(VIEW_CLOSE,        "Close the current view"), \
 308         REQ_(QUIT,              "Close all views and quit"), \
 309         \
 310         REQ_GROUP("Cursor navigation") \
 311         REQ_(MOVE_UP,           "Move cursor one line up"), \
 312         REQ_(MOVE_DOWN,         "Move cursor one line down"), \
 313         REQ_(MOVE_PAGE_DOWN,    "Move cursor one page down"), \
 314         REQ_(MOVE_PAGE_UP,      "Move cursor one page up"), \
 315         REQ_(MOVE_FIRST_LINE,   "Move cursor to first line"), \
 316         REQ_(MOVE_LAST_LINE,    "Move cursor to last line"), \
 317         \
 318         REQ_GROUP("Scrolling") \
 319         REQ_(SCROLL_LINE_UP,    "Scroll one line up"), \
 320         REQ_(SCROLL_LINE_DOWN,  "Scroll one line down"), \
 321         REQ_(SCROLL_PAGE_UP,    "Scroll one page up"), \
 322         REQ_(SCROLL_PAGE_DOWN,  "Scroll one page down"), \
 323         \
 324         REQ_GROUP("Searching") \
 325         REQ_(SEARCH,            "Search the view"), \
 326         REQ_(SEARCH_BACK,       "Search backwards in the view"), \
 327         REQ_(FIND_NEXT,         "Find next search match"), \
 328         REQ_(FIND_PREV,         "Find previous search match"), \
 329         \
 330         REQ_GROUP("Misc") \
 331         REQ_(NONE,              "Do nothing"), \
 332         REQ_(PROMPT,            "Bring up the prompt"), \
 333         REQ_(SCREEN_REDRAW,     "Redraw the screen"), \
 334         REQ_(SCREEN_RESIZE,     "Resize the screen"), \
 335         REQ_(SHOW_VERSION,      "Show version information"), \
 336         REQ_(STOP_LOADING,      "Stop all loading views"), \
 337         REQ_(TOGGLE_LINENO,     "Toggle line numbers"), \
 338         REQ_(TOGGLE_REV_GRAPH,  "Toggle revision graph visualization")
 339
 340
 341 /* User action requests. */
 342 enum request {
 343 #define REQ_GROUP(help)
 344 #define REQ_(req, help) REQ_##req
 345
 346         /* Offset all requests to avoid conflicts with ncurses getch values. */
 347         REQ_OFFSET = KEY_MAX + 1,
 348         REQ_INFO,
 349         REQ_UNKNOWN,
 350
 351 #undef  REQ_GROUP
 352 #undef  REQ_
 353 };
 354
 355 struct request_info {
 356         enum request request;
 357         char *name;
 358         int namelen;
 359         char *help;
 360 };
 361
 362 static struct request_info req_info[] = {
 363 #define REQ_GROUP(help) { 0, NULL, 0, (help) },
 364 #define REQ_(req, help) { REQ_##req, (#req), STRING_SIZE(#req), (help) }
 365         REQ_INFO
 366 #undef  REQ_GROUP
 367 #undef  REQ_
 368 };
 369
 370 static enum request
 371 get_request(const char *name)
 372 {
 373         int namelen = strlen(name);
 374         int i;
 375
 376         for (i = 0; i < ARRAY_SIZE(req_info); i++)
 377                 if (req_info[i].namelen == namelen &&
 378                     !string_enum_compare(req_info[i].name, name, namelen))
 379                         return req_info[i].request;
 380
 381         return REQ_UNKNOWN;
 382 }
 383
 384
 385 /*
 386  * Options
 387  */
 388
 389 static const char usage[] =
 390 "tig " VERSION " (" __DATE__ ")\n"
 391 "\n"
 392 "Usage: tig [options]\n"
 393 "   or: tig [options] [--] [git log options]\n"
 394 "   or: tig [options] log  [git log options]\n"
 395 "   or: tig [options] diff [git diff options]\n"
 396 "   or: tig [options] show [git show options]\n"
 397 "   or: tig [options] <    [git command output]\n"
 398 "\n"
 399 "Options:\n"
 400 "  -l                          Start up in log view\n"
 401 "  -d                          Start up in diff view\n"
 402 "  -S                          Start up in status view\n"
 403 "  -n[I], --line-number[=I]    Show line numbers with given interval\n"
 404 "  -b[N], --tab-size[=N]       Set number of spaces for tab expansion\n"
 405 "  --                          Mark end of tig options\n"
 406 "  -v, --version               Show version and exit\n"
 407 "  -h, --help                  Show help message and exit\n";
 408
 409 /* Option and state variables. */
 410 static bool opt_line_number             = FALSE;
 411 static bool opt_rev_graph               = FALSE;
 412 static int opt_num_interval             = NUMBER_INTERVAL;
 413 static int opt_tab_size                 = TABSIZE;
 414 static enum request opt_request         = REQ_VIEW_MAIN;
 415 static char opt_cmd[SIZEOF_STR]         = "";
 416 static char opt_path[SIZEOF_STR]        = "";
 417 static FILE *opt_pipe                   = NULL;
 418 static char opt_encoding[20]            = "UTF-8";
 419 static bool opt_utf8                    = TRUE;
 420 static char opt_codeset[20]             = "UTF-8";
 421 static iconv_t opt_iconv                = ICONV_NONE;
 422 static char opt_search[SIZEOF_STR]      = "";
 423 static char opt_cdup[SIZEOF_STR]        = "";
 424
 425 enum option_type {
 426         OPT_NONE,
 427         OPT_INT,
 428 };
 429
 430 static bool
 431 check_option(char *opt, char short_name, char *name, enum option_type type, ...)
 432 {
 433         va_list args;
 434         char *value = "";
 435         int *number;
 436
 437         if (opt[0] != '-')
 438                 return FALSE;
 439
 440         if (opt[1] == '-') {
 441                 int namelen = strlen(name);
 442
 443                 opt += 2;
 444
 445                 if (strncmp(opt, name, namelen))
 446                         return FALSE;
 447
 448                 if (opt[namelen] == '=')
 449                         value = opt + namelen + 1;
 450
 451         } else {
 452                 if (!short_name || opt[1] != short_name)
 453                         return FALSE;
 454                 value = opt + 2;
 455         }
 456
 457         va_start(args, type);
 458         if (type == OPT_INT) {
 459                 number = va_arg(args, int *);
 460                 if (isdigit(*value))
 461                         *number = atoi(value);
 462         }
 463         va_end(args);
 464
 465         return TRUE;
 466 }
 467
 468 /* Returns the index of log or diff command or -1 to exit. */
 469 static bool
 470 parse_options(int argc, char *argv[])
 471 {
 472         int i;
 473
 474         for (i = 1; i < argc; i++) {
 475                 char *opt = argv[i];
 476
 477                 if (!strcmp(opt, "log") ||
 478                     !strcmp(opt, "diff") ||
 479                     !strcmp(opt, "show")) {
 480                         opt_request = opt[0] == 'l'
 481                                     ? REQ_VIEW_LOG : REQ_VIEW_DIFF;
 482                         break;
 483                 }
 484
 485                 if (opt[0] && opt[0] != '-')
 486                         break;
 487
 488                 if (!strcmp(opt, "-l")) {
 489                         opt_request = REQ_VIEW_LOG;
 490                         continue;
 491                 }
 492
 493                 if (!strcmp(opt, "-d")) {
 494                         opt_request = REQ_VIEW_DIFF;
 495                         continue;
 496                 }
 497
 498                 if (!strcmp(opt, "-S")) {
 499                         opt_request = REQ_VIEW_STATUS;
 500                         break;
 501                 }
 502
 503                 if (check_option(opt, 'n', "line-number", OPT_INT, &opt_num_interval)) {
 504                         opt_line_number = TRUE;
 505                         continue;
 506                 }
 507
 508                 if (check_option(opt, 'b', "tab-size", OPT_INT, &opt_tab_size)) {
 509                         opt_tab_size = MIN(opt_tab_size, TABSIZE);
 510                         continue;
 511                 }
 512
 513                 if (check_option(opt, 'v', "version", OPT_NONE)) {
 514                         printf("tig version %s\n", VERSION);
 515                         return FALSE;
 516                 }
 517
 518                 if (check_option(opt, 'h', "help", OPT_NONE)) {
 519                         printf(usage);
 520                         return FALSE;
 521                 }
 522
 523                 if (!strcmp(opt, "--")) {
 524                         i++;
 525                         break;
 526                 }
 527
 528                 die("unknown option '%s'\n\n%s", opt, usage);
 529         }
 530
 531         if (!isatty(STDIN_FILENO)) {
 532                 opt_request = REQ_VIEW_PAGER;
 533                 opt_pipe = stdin;
 534
 535         } else if (i < argc) {
 536                 size_t buf_size;
 537
 538                 if (opt_request == REQ_VIEW_MAIN)
 539                         /* XXX: This is vulnerable to the user overriding
 540                          * options required for the main view parser. */
 541                         string_copy(opt_cmd, "git log --pretty=raw");
 542                 else
 543                         string_copy(opt_cmd, "git");
 544                 buf_size = strlen(opt_cmd);
 545
 546                 while (buf_size < sizeof(opt_cmd) && i < argc) {
 547                         opt_cmd[buf_size++] = ' ';
 548                         buf_size = sq_quote(opt_cmd, buf_size, argv[i++]);
 549                 }
 550
 551                 if (buf_size >= sizeof(opt_cmd))
 552                         die("command too long");
 553
 554                 opt_cmd[buf_size] = 0;
 555         }
 556
 557         if (*opt_encoding && strcasecmp(opt_encoding, "UTF-8"))
 558                 opt_utf8 = FALSE;
 559
 560         return TRUE;
 561 }
 562
 563
 564 /*
 565  * Line-oriented content detection.
 566  */
 567
 568 #define LINE_INFO \
 569 LINE(DIFF_HEADER,  "diff --git ",       COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 570 LINE(DIFF_CHUNK,   "@@",                COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
 571 LINE(DIFF_ADD,     "+",                 COLOR_GREEN,    COLOR_DEFAULT,  0), \
 572 LINE(DIFF_DEL,     "-",                 COLOR_RED,      COLOR_DEFAULT,  0), \
 573 LINE(DIFF_INDEX,        "index ",         COLOR_BLUE,   COLOR_DEFAULT,  0), \
 574 LINE(DIFF_OLDMODE,      "old file mode ", COLOR_YELLOW, COLOR_DEFAULT,  0), \
 575 LINE(DIFF_NEWMODE,      "new file mode ", COLOR_YELLOW, COLOR_DEFAULT,  0), \
 576 LINE(DIFF_COPY_FROM,    "copy from",      COLOR_YELLOW, COLOR_DEFAULT,  0), \
 577 LINE(DIFF_COPY_TO,      "copy to",        COLOR_YELLOW, COLOR_DEFAULT,  0), \
 578 LINE(DIFF_RENAME_FROM,  "rename from",    COLOR_YELLOW, COLOR_DEFAULT,  0), \
 579 LINE(DIFF_RENAME_TO,    "rename to",      COLOR_YELLOW, COLOR_DEFAULT,  0), \
 580 LINE(DIFF_SIMILARITY,   "similarity ",    COLOR_YELLOW, COLOR_DEFAULT,  0), \
 581 LINE(DIFF_DISSIMILARITY,"dissimilarity ", COLOR_YELLOW, COLOR_DEFAULT,  0), \
 582 LINE(DIFF_TREE,         "diff-tree ",     COLOR_BLUE,   COLOR_DEFAULT,  0), \
 583 LINE(PP_AUTHOR,    "Author: ",          COLOR_CYAN,     COLOR_DEFAULT,  0), \
 584 LINE(PP_COMMIT,    "Commit: ",          COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
 585 LINE(PP_MERGE,     "Merge: ",           COLOR_BLUE,     COLOR_DEFAULT,  0), \
 586 LINE(PP_DATE,      "Date:   ",          COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 587 LINE(PP_ADATE,     "AuthorDate: ",      COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 588 LINE(PP_CDATE,     "CommitDate: ",      COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 589 LINE(PP_REFS,      "Refs: ",            COLOR_RED,      COLOR_DEFAULT,  0), \
 590 LINE(COMMIT,       "commit ",           COLOR_GREEN,    COLOR_DEFAULT,  0), \
 591 LINE(PARENT,       "parent ",           COLOR_BLUE,     COLOR_DEFAULT,  0), \
 592 LINE(TREE,         "tree ",             COLOR_BLUE,     COLOR_DEFAULT,  0), \
 593 LINE(AUTHOR,       "author ",           COLOR_CYAN,     COLOR_DEFAULT,  0), \
 594 LINE(COMMITTER,    "committer ",        COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
 595 LINE(SIGNOFF,      "    Signed-off-by", COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 596 LINE(ACKED,        "    Acked-by",      COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 597 LINE(DEFAULT,      "",                  COLOR_DEFAULT,  COLOR_DEFAULT,  A_NORMAL), \
 598 LINE(CURSOR,       "",                  COLOR_WHITE,    COLOR_GREEN,    A_BOLD), \
 599 LINE(STATUS,       "",                  COLOR_GREEN,    COLOR_DEFAULT,  0), \
 600 LINE(TITLE_BLUR,   "",                  COLOR_WHITE,    COLOR_BLUE,     0), \
 601 LINE(TITLE_FOCUS,  "",                  COLOR_WHITE,    COLOR_BLUE,     A_BOLD), \
 602 LINE(MAIN_DATE,    "",                  COLOR_BLUE,     COLOR_DEFAULT,  0), \
 603 LINE(MAIN_AUTHOR,  "",                  COLOR_GREEN,    COLOR_DEFAULT,  0), \
 604 LINE(MAIN_COMMIT,  "",                  COLOR_DEFAULT,  COLOR_DEFAULT,  0), \
 605 LINE(MAIN_DELIM,   "",                  COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
 606 LINE(MAIN_TAG,     "",                  COLOR_MAGENTA,  COLOR_DEFAULT,  A_BOLD), \
 607 LINE(MAIN_REMOTE,  "",                  COLOR_YELLOW,   COLOR_DEFAULT,  A_BOLD), \
 608 LINE(MAIN_REF,     "",                  COLOR_CYAN,     COLOR_DEFAULT,  A_BOLD), \
 609 LINE(TREE_DIR,     "",                  COLOR_DEFAULT,  COLOR_DEFAULT,  A_NORMAL), \
 610 LINE(TREE_FILE,    "",                  COLOR_DEFAULT,  COLOR_DEFAULT,  A_NORMAL), \
 611 LINE(STAT_SECTION, "",                  COLOR_DEFAULT,  COLOR_BLUE,     A_BOLD), \
 612 LINE(STAT_NONE,    "",                  COLOR_DEFAULT,  COLOR_DEFAULT,  0), \
 613 LINE(STAT_STAGED,  "",                  COLOR_CYAN,     COLOR_DEFAULT,  0), \
 614 LINE(STAT_UNSTAGED,"",                  COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 615 LINE(STAT_UNTRACKED,"",                 COLOR_MAGENTA,  COLOR_DEFAULT,  0)
 616
 617 enum line_type {
 618 #define LINE(type, line, fg, bg, attr) \
 619         LINE_##type
 620         LINE_INFO
 621 #undef  LINE
 622 };
 623
 624 struct line_info {
 625         const char *name;       /* Option name. */
 626         int namelen;            /* Size of option name. */
 627         const char *line;       /* The start of line to match. */
 628         int linelen;            /* Size of string to match. */
 629         int fg, bg, attr;       /* Color and text attributes for the lines. */
 630 };
 631
 632 static struct line_info line_info[] = {
 633 #define LINE(type, line, fg, bg, attr) \
 634         { #type, STRING_SIZE(#type), (line), STRING_SIZE(line), (fg), (bg), (attr) }
 635         LINE_INFO
 636 #undef  LINE
 637 };
 638
 639 static enum line_type
 640 get_line_type(char *line)
 641 {
 642         int linelen = strlen(line);
 643         enum line_type type;
 644
 645         for (type = 0; type < ARRAY_SIZE(line_info); type++)
 646                 /* Case insensitive search matches Signed-off-by lines better. */
 647                 if (linelen >= line_info[type].linelen &&
 648                     !strncasecmp(line_info[type].line, line, line_info[type].linelen))
 649                         return type;
 650
 651         return LINE_DEFAULT;
 652 }
 653
 654 static inline int
 655 get_line_attr(enum line_type type)
 656 {
 657         assert(type < ARRAY_SIZE(line_info));
 658         return COLOR_PAIR(type) | line_info[type].attr;
 659 }
 660
 661 static struct line_info *
 662 get_line_info(char *name, int namelen)
 663 {
 664         enum line_type type;
 665
 666         for (type = 0; type < ARRAY_SIZE(line_info); type++)
 667                 if (namelen == line_info[type].namelen &&
 668                     !string_enum_compare(line_info[type].name, name, namelen))
 669                         return &line_info[type];
 670
 671         return NULL;
 672 }
 673
 674 static void
 675 init_colors(void)
 676 {
 677         int default_bg = COLOR_BLACK;
 678         int default_fg = COLOR_WHITE;
 679         enum line_type type;
 680
 681         start_color();
 682
 683         if (use_default_colors() != ERR) {
 684                 default_bg = -1;
 685                 default_fg = -1;
 686         }
 687
 688         for (type = 0; type < ARRAY_SIZE(line_info); type++) {
 689                 struct line_info *info = &line_info[type];
 690                 int bg = info->bg == COLOR_DEFAULT ? default_bg : info->bg;
 691                 int fg = info->fg == COLOR_DEFAULT ? default_fg : info->fg;
 692
 693                 init_pair(type, fg, bg);
 694         }
 695 }
 696
 697 struct line {
 698         enum line_type type;
 699
 700         /* State flags */
 701         unsigned int selected: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         { 'p',          REQ_VIEW_PAGER },
 725         { 'h',          REQ_VIEW_HELP },
 726         { 'S',          REQ_VIEW_STATUS },
 727
 728         /* View manipulation */
 729         { 'q',          REQ_VIEW_CLOSE },
 730         { KEY_TAB,      REQ_VIEW_NEXT },
 731         { KEY_RETURN,   REQ_ENTER },
 732         { KEY_UP,       REQ_PREVIOUS },
 733         { KEY_DOWN,     REQ_NEXT },
 734
 735         /* Cursor navigation */
 736         { 'k',          REQ_MOVE_UP },
 737         { 'j',          REQ_MOVE_DOWN },
 738         { KEY_HOME,     REQ_MOVE_FIRST_LINE },
 739         { KEY_END,      REQ_MOVE_LAST_LINE },
 740         { KEY_NPAGE,    REQ_MOVE_PAGE_DOWN },
 741         { ' ',          REQ_MOVE_PAGE_DOWN },
 742         { KEY_PPAGE,    REQ_MOVE_PAGE_UP },
 743         { 'b',          REQ_MOVE_PAGE_UP },
 744         { '-',          REQ_MOVE_PAGE_UP },
 745
 746         /* Scrolling */
 747         { KEY_IC,       REQ_SCROLL_LINE_UP },
 748         { KEY_DC,       REQ_SCROLL_LINE_DOWN },
 749         { 'w',          REQ_SCROLL_PAGE_UP },
 750         { 's',          REQ_SCROLL_PAGE_DOWN },
 751
 752         /* Searching */
 753         { '/',          REQ_SEARCH },
 754         { '?',          REQ_SEARCH_BACK },
 755         { 'n',          REQ_FIND_NEXT },
 756         { 'N',          REQ_FIND_PREV },
 757
 758         /* Misc */
 759         { 'Q',          REQ_QUIT },
 760         { 'z',          REQ_STOP_LOADING },
 761         { 'v',          REQ_SHOW_VERSION },
 762         { 'r',          REQ_SCREEN_REDRAW },
 763         { '.',          REQ_TOGGLE_LINENO },
 764         { 'g',          REQ_TOGGLE_REV_GRAPH },
 765         { ':',          REQ_PROMPT },
 766
 767         /* Using the ncurses SIGWINCH handler. */
 768         { KEY_RESIZE,   REQ_SCREEN_RESIZE },
 769 };
 770
 771 #define KEYMAP_INFO \
 772         KEYMAP_(GENERIC), \
 773         KEYMAP_(MAIN), \
 774         KEYMAP_(DIFF), \
 775         KEYMAP_(LOG), \
 776         KEYMAP_(TREE), \
 777         KEYMAP_(BLOB), \
 778         KEYMAP_(PAGER), \
 779         KEYMAP_(HELP), \
 780         KEYMAP_(STATUS)
 781
 782 enum keymap {
 783 #define KEYMAP_(name) KEYMAP_##name
 784         KEYMAP_INFO
 785 #undef  KEYMAP_
 786 };
 787
 788 static struct int_map keymap_table[] = {
 789 #define KEYMAP_(name) { #name, STRING_SIZE(#name), KEYMAP_##name }
 790         KEYMAP_INFO
 791 #undef  KEYMAP_
 792 };
 793
 794 #define set_keymap(map, name) \
 795         set_from_int_map(keymap_table, ARRAY_SIZE(keymap_table), map, name, strlen(name))
 796
 797 static struct keybinding *keybindings[ARRAY_SIZE(keymap_table)];
 798
 799 static void
 800 add_keybinding(enum keymap keymap, enum request request, int key)
 801 {
 802         struct keybinding *keybinding;
 803
 804         keybinding = calloc(1, sizeof(*keybinding));
 805         if (!keybinding)
 806                 die("Failed to allocate keybinding");
 807
 808         keybinding->alias = key;
 809         keybinding->request = request;
 810         keybinding->next = keybindings[keymap];
 811         keybindings[keymap] = keybinding;
 812 }
 813
 814 /* Looks for a key binding first in the given map, then in the generic map, and
 815  * lastly in the default keybindings. */
 816 static enum request
 817 get_keybinding(enum keymap keymap, int key)
 818 {
 819         struct keybinding *kbd;
 820         int i;
 821
 822         for (kbd = keybindings[keymap]; kbd; kbd = kbd->next)
 823                 if (kbd->alias == key)
 824                         return kbd->request;
 825
 826         for (kbd = keybindings[KEYMAP_GENERIC]; kbd; kbd = kbd->next)
 827                 if (kbd->alias == key)
 828                         return kbd->request;
 829
 830         for (i = 0; i < ARRAY_SIZE(default_keybindings); i++)
 831                 if (default_keybindings[i].alias == key)
 832                         return default_keybindings[i].request;
 833
 834         return (enum request) key;
 835 }
 836
 837
 838 struct key {
 839         char *name;
 840         int value;
 841 };
 842
 843 static struct key key_table[] = {
 844         { "Enter",      KEY_RETURN },
 845         { "Space",      ' ' },
 846         { "Backspace",  KEY_BACKSPACE },
 847         { "Tab",        KEY_TAB },
 848         { "Escape",     KEY_ESC },
 849         { "Left",       KEY_LEFT },
 850         { "Right",      KEY_RIGHT },
 851         { "Up",         KEY_UP },
 852         { "Down",       KEY_DOWN },
 853         { "Insert",     KEY_IC },
 854         { "Delete",     KEY_DC },
 855         { "Hash",       '#' },
 856         { "Home",       KEY_HOME },
 857         { "End",        KEY_END },
 858         { "PageUp",     KEY_PPAGE },
 859         { "PageDown",   KEY_NPAGE },
 860         { "F1",         KEY_F(1) },
 861         { "F2",         KEY_F(2) },
 862         { "F3",         KEY_F(3) },
 863         { "F4",         KEY_F(4) },
 864         { "F5",         KEY_F(5) },
 865         { "F6",         KEY_F(6) },
 866         { "F7",         KEY_F(7) },
 867         { "F8",         KEY_F(8) },
 868         { "F9",         KEY_F(9) },
 869         { "F10",        KEY_F(10) },
 870         { "F11",        KEY_F(11) },
 871         { "F12",        KEY_F(12) },
 872 };
 873
 874 static int
 875 get_key_value(const char *name)
 876 {
 877         int i;
 878
 879         for (i = 0; i < ARRAY_SIZE(key_table); i++)
 880                 if (!strcasecmp(key_table[i].name, name))
 881                         return key_table[i].value;
 882
 883         if (strlen(name) == 1 && isprint(*name))
 884                 return (int) *name;
 885
 886         return ERR;
 887 }
 888
 889 static char *
 890 get_key(enum request request)
 891 {
 892         static char buf[BUFSIZ];
 893         static char key_char[] = "'X'";
 894         size_t pos = 0;
 895         char *sep = "";
 896         int i;
 897
 898         buf[pos] = 0;
 899
 900         for (i = 0; i < ARRAY_SIZE(default_keybindings); i++) {
 901                 struct keybinding *keybinding = &default_keybindings[i];
 902                 char *seq = NULL;
 903                 int key;
 904
 905                 if (keybinding->request != request)
 906                         continue;
 907
 908                 for (key = 0; key < ARRAY_SIZE(key_table); key++)
 909                         if (key_table[key].value == keybinding->alias)
 910                                 seq = key_table[key].name;
 911
 912                 if (seq == NULL &&
 913                     keybinding->alias < 127 &&
 914                     isprint(keybinding->alias)) {
 915                         key_char[1] = (char) keybinding->alias;
 916                         seq = key_char;
 917                 }
 918
 919                 if (!seq)
 920                         seq = "'?'";
 921
 922                 if (!string_format_from(buf, &pos, "%s%s", sep, seq))
 923                         return "Too many keybindings!";
 924                 sep = ", ";
 925         }
 926
 927         return buf;
 928 }
 929
 930
 931 /*
 932  * User config file handling.
 933  */
 934
 935 static struct int_map color_map[] = {
 936 #define COLOR_MAP(name) { #name, STRING_SIZE(#name), COLOR_##name }
 937         COLOR_MAP(DEFAULT),
 938         COLOR_MAP(BLACK),
 939         COLOR_MAP(BLUE),
 940         COLOR_MAP(CYAN),
 941         COLOR_MAP(GREEN),
 942         COLOR_MAP(MAGENTA),
 943         COLOR_MAP(RED),
 944         COLOR_MAP(WHITE),
 945         COLOR_MAP(YELLOW),
 946 };
 947
 948 #define set_color(color, name) \
 949         set_from_int_map(color_map, ARRAY_SIZE(color_map), color, name, strlen(name))
 950
 951 static struct int_map attr_map[] = {
 952 #define ATTR_MAP(name) { #name, STRING_SIZE(#name), A_##name }
 953         ATTR_MAP(NORMAL),
 954         ATTR_MAP(BLINK),
 955         ATTR_MAP(BOLD),
 956         ATTR_MAP(DIM),
 957         ATTR_MAP(REVERSE),
 958         ATTR_MAP(STANDOUT),
 959         ATTR_MAP(UNDERLINE),
 960 };
 961
 962 #define set_attribute(attr, name) \
 963         set_from_int_map(attr_map, ARRAY_SIZE(attr_map), attr, name, strlen(name))
 964
 965 static int   config_lineno;
 966 static bool  config_errors;
 967 static char *config_msg;
 968
 969 /* Wants: object fgcolor bgcolor [attr] */
 970 static int
 971 option_color_command(int argc, char *argv[])
 972 {
 973         struct line_info *info;
 974
 975         if (argc != 3 && argc != 4) {
 976                 config_msg = "Wrong number of arguments given to color command";
 977                 return ERR;
 978         }
 979
 980         info = get_line_info(argv[0], strlen(argv[0]));
 981         if (!info) {
 982                 config_msg = "Unknown color name";
 983                 return ERR;
 984         }
 985
 986         if (set_color(&info->fg, argv[1]) == ERR ||
 987             set_color(&info->bg, argv[2]) == ERR) {
 988                 config_msg = "Unknown color";
 989                 return ERR;
 990         }
 991
 992         if (argc == 4 && set_attribute(&info->attr, argv[3]) == ERR) {
 993                 config_msg = "Unknown attribute";
 994                 return ERR;
 995         }
 996
 997         return OK;
 998 }
 999
1000 /* Wants: name = value */
1001 static int
1002 option_set_command(int argc, char *argv[])
1003 {
1004         if (argc != 3) {
1005                 config_msg = "Wrong number of arguments given to set command";
1006                 return ERR;
1007         }
1008
1009         if (strcmp(argv[1], "=")) {
1010                 config_msg = "No value assigned";
1011                 return ERR;
1012         }
1013
1014         if (!strcmp(argv[0], "show-rev-graph")) {
1015                 opt_rev_graph = (!strcmp(argv[2], "1") ||
1016                                  !strcmp(argv[2], "true") ||
1017                                  !strcmp(argv[2], "yes"));
1018                 return OK;
1019         }
1020
1021         if (!strcmp(argv[0], "line-number-interval")) {
1022                 opt_num_interval = atoi(argv[2]);
1023                 return OK;
1024         }
1025
1026         if (!strcmp(argv[0], "tab-size")) {
1027                 opt_tab_size = atoi(argv[2]);
1028                 return OK;
1029         }
1030
1031         if (!strcmp(argv[0], "commit-encoding")) {
1032                 char *arg = argv[2];
1033                 int delimiter = *arg;
1034                 int i;
1035
1036                 switch (delimiter) {
1037                 case '"':
1038                 case '\'':
1039                         for (arg++, i = 0; arg[i]; i++)
1040                                 if (arg[i] == delimiter) {
1041                                         arg[i] = 0;
1042                                         break;
1043                                 }
1044                 default:
1045                         string_ncopy(opt_encoding, arg, strlen(arg));
1046                         return OK;
1047                 }
1048         }
1049
1050         config_msg = "Unknown variable name";
1051         return ERR;
1052 }
1053
1054 /* Wants: mode request key */
1055 static int
1056 option_bind_command(int argc, char *argv[])
1057 {
1058         enum request request;
1059         int keymap;
1060         int key;
1061
1062         if (argc != 3) {
1063                 config_msg = "Wrong number of arguments given to bind command";
1064                 return ERR;
1065         }
1066
1067         if (set_keymap(&keymap, argv[0]) == ERR) {
1068                 config_msg = "Unknown key map";
1069                 return ERR;
1070         }
1071
1072         key = get_key_value(argv[1]);
1073         if (key == ERR) {
1074                 config_msg = "Unknown key";
1075                 return ERR;
1076         }
1077
1078         request = get_request(argv[2]);
1079         if (request == REQ_UNKNOWN) {
1080                 config_msg = "Unknown request name";
1081                 return ERR;
1082         }
1083
1084         add_keybinding(keymap, request, key);
1085
1086         return OK;
1087 }
1088
1089 static int
1090 set_option(char *opt, char *value)
1091 {
1092         char *argv[16];
1093         int valuelen;
1094         int argc = 0;
1095
1096         /* Tokenize */
1097         while (argc < ARRAY_SIZE(argv) && (valuelen = strcspn(value, " \t"))) {
1098                 argv[argc++] = value;
1099
1100                 value += valuelen;
1101                 if (!*value)
1102                         break;
1103
1104                 *value++ = 0;
1105                 while (isspace(*value))
1106                         value++;
1107         }
1108
1109         if (!strcmp(opt, "color"))
1110                 return option_color_command(argc, argv);
1111
1112         if (!strcmp(opt, "set"))
1113                 return option_set_command(argc, argv);
1114
1115         if (!strcmp(opt, "bind"))
1116                 return option_bind_command(argc, argv);
1117
1118         config_msg = "Unknown option command";
1119         return ERR;
1120 }
1121
1122 static int
1123 read_option(char *opt, size_t optlen, char *value, size_t valuelen)
1124 {
1125         int status = OK;
1126
1127         config_lineno++;
1128         config_msg = "Internal error";
1129
1130         /* Check for comment markers, since read_properties() will
1131          * only ensure opt and value are split at first " \t". */
1132         optlen = strcspn(opt, "#");
1133         if (optlen == 0)
1134                 return OK;
1135
1136         if (opt[optlen] != 0) {
1137                 config_msg = "No option value";
1138                 status = ERR;
1139
1140         }  else {
1141                 /* Look for comment endings in the value. */
1142                 size_t len = strcspn(value, "#");
1143
1144                 if (len < valuelen) {
1145                         valuelen = len;
1146                         value[valuelen] = 0;
1147                 }
1148
1149                 status = set_option(opt, value);
1150         }
1151
1152         if (status == ERR) {
1153                 fprintf(stderr, "Error on line %d, near '%.*s': %s\n",
1154                         config_lineno, optlen, opt, config_msg);
1155                 config_errors = TRUE;
1156         }
1157
1158         /* Always keep going if errors are encountered. */
1159         return OK;
1160 }
1161
1162 static int
1163 load_options(void)
1164 {
1165         char *home = getenv("HOME");
1166         char buf[SIZEOF_STR];
1167         FILE *file;
1168
1169         config_lineno = 0;
1170         config_errors = FALSE;
1171
1172         if (!home || !string_format(buf, "%s/.tigrc", home))
1173                 return ERR;
1174
1175         /* It's ok that the file doesn't exist. */
1176         file = fopen(buf, "r");
1177         if (!file)
1178                 return OK;
1179
1180         if (read_properties(file, " \t", read_option) == ERR ||
1181             config_errors == TRUE)
1182                 fprintf(stderr, "Errors while loading %s.\n", buf);
1183
1184         return OK;
1185 }
1186
1187
1188 /*
1189  * The viewer
1190  */
1191
1192 struct view;
1193 struct view_ops;
1194
1195 /* The display array of active views and the index of the current view. */
1196 static struct view *display[2];
1197 static unsigned int current_view;
1198
1199 /* Reading from the prompt? */
1200 static bool input_mode = FALSE;
1201
1202 #define foreach_displayed_view(view, i) \
1203         for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
1204
1205 #define displayed_views()       (display[1] != NULL ? 2 : 1)
1206
1207 /* Current head and commit ID */
1208 static char ref_blob[SIZEOF_REF]        = "";
1209 static char ref_commit[SIZEOF_REF]      = "HEAD";
1210 static char ref_head[SIZEOF_REF]        = "HEAD";
1211
1212 struct view {
1213         const char *name;       /* View name */
1214         const char *cmd_fmt;    /* Default command line format */
1215         const char *cmd_env;    /* Command line set via environment */
1216         const char *id;         /* Points to either of ref_{head,commit,blob} */
1217
1218         struct view_ops *ops;   /* View operations */
1219
1220         enum keymap keymap;     /* What keymap does this view have */
1221
1222         char cmd[SIZEOF_STR];   /* Command buffer */
1223         char ref[SIZEOF_REF];   /* Hovered commit reference */
1224         char vid[SIZEOF_REF];   /* View ID. Set to id member when updating. */
1225
1226         int height, width;      /* The width and height of the main window */
1227         WINDOW *win;            /* The main window */
1228         WINDOW *title;          /* The title window living below the main window */
1229
1230         /* Navigation */
1231         unsigned long offset;   /* Offset of the window top */
1232         unsigned long lineno;   /* Current line number */
1233
1234         /* Searching */
1235         char grep[SIZEOF_STR];  /* Search string */
1236         regex_t *regex;         /* Pre-compiled regex */
1237
1238         /* If non-NULL, points to the view that opened this view. If this view
1239          * is closed tig will switch back to the parent view. */
1240         struct view *parent;
1241
1242         /* Buffering */
1243         unsigned long lines;    /* Total number of lines */
1244         struct line *line;      /* Line index */
1245         unsigned long line_size;/* Total number of allocated lines */
1246         unsigned int digits;    /* Number of digits in the lines member. */
1247
1248         /* Loading */
1249         FILE *pipe;
1250         time_t start_time;
1251 };
1252
1253 struct view_ops {
1254         /* What type of content being displayed. Used in the title bar. */
1255         const char *type;
1256         /* Open and reads in all view content. */
1257         bool (*open)(struct view *view);
1258         /* Read one line; updates view->line. */
1259         bool (*read)(struct view *view, char *data);
1260         /* Draw one line; @lineno must be < view->height. */
1261         bool (*draw)(struct view *view, struct line *line, unsigned int lineno, bool selected);
1262         /* Depending on view, change display based on current line. */
1263         bool (*enter)(struct view *view, struct line *line);
1264         /* Search for regex in a line. */
1265         bool (*grep)(struct view *view, struct line *line);
1266         /* Select line */
1267         void (*select)(struct view *view, struct line *line);
1268 };
1269
1270 static struct view_ops pager_ops;
1271 static struct view_ops main_ops;
1272 static struct view_ops tree_ops;
1273 static struct view_ops blob_ops;
1274 static struct view_ops help_ops;
1275 static struct view_ops status_ops;
1276
1277 #define VIEW_STR(name, cmd, env, ref, ops, map) \
1278         { name, cmd, #env, ref, ops, map}
1279
1280 #define VIEW_(id, name, ops, ref) \
1281         VIEW_STR(name, TIG_##id##_CMD,  TIG_##id##_CMD, ref, ops, KEYMAP_##id)
1282
1283
1284 static struct view views[] = {
1285         VIEW_(MAIN,   "main",   &main_ops,   ref_head),
1286         VIEW_(DIFF,   "diff",   &pager_ops,  ref_commit),
1287         VIEW_(LOG,    "log",    &pager_ops,  ref_head),
1288         VIEW_(TREE,   "tree",   &tree_ops,   ref_commit),
1289         VIEW_(BLOB,   "blob",   &blob_ops,   ref_blob),
1290         VIEW_(HELP,   "help",   &help_ops,  ""),
1291         VIEW_(PAGER,  "pager",  &pager_ops,  ""),
1292         VIEW_(STATUS, "status", &status_ops, ""),
1293 };
1294
1295 #define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
1296
1297 #define foreach_view(view, i) \
1298         for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
1299
1300 #define view_is_displayed(view) \
1301         (view == display[0] || view == display[1])
1302
1303 static bool
1304 draw_view_line(struct view *view, unsigned int lineno)
1305 {
1306         struct line *line;
1307         bool selected = (view->offset + lineno == view->lineno);
1308         bool draw_ok;
1309
1310         assert(view_is_displayed(view));
1311
1312         if (view->offset + lineno >= view->lines)
1313                 return FALSE;
1314
1315         line = &view->line[view->offset + lineno];
1316
1317         if (selected) {
1318                 line->selected = TRUE;
1319                 view->ops->select(view, line);
1320         } else if (line->selected) {
1321                 line->selected = FALSE;
1322                 wmove(view->win, lineno, 0);
1323                 wclrtoeol(view->win);
1324         }
1325
1326         scrollok(view->win, FALSE);
1327         draw_ok = view->ops->draw(view, line, lineno, selected);
1328         scrollok(view->win, TRUE);
1329
1330         return draw_ok;
1331 }
1332
1333 static void
1334 redraw_view_from(struct view *view, int lineno)
1335 {
1336         assert(0 <= lineno && lineno < view->height);
1337
1338         for (; lineno < view->height; lineno++) {
1339                 if (!draw_view_line(view, lineno))
1340                         break;
1341         }
1342
1343         redrawwin(view->win);
1344         if (input_mode)
1345                 wnoutrefresh(view->win);
1346         else
1347                 wrefresh(view->win);
1348 }
1349
1350 static void
1351 redraw_view(struct view *view)
1352 {
1353         wclear(view->win);
1354         redraw_view_from(view, 0);
1355 }
1356
1357
1358 static void
1359 update_view_title(struct view *view)
1360 {
1361         char buf[SIZEOF_STR];
1362         char state[SIZEOF_STR];
1363         size_t bufpos = 0, statelen = 0;
1364
1365         assert(view_is_displayed(view));
1366
1367         if (view->lines || view->pipe) {
1368                 unsigned int view_lines = view->offset + view->height;
1369                 unsigned int lines = view->lines
1370                                    ? MIN(view_lines, view->lines) * 100 / view->lines
1371                                    : 0;
1372
1373                 string_format_from(state, &statelen, "- %s %d of %d (%d%%)",
1374                                    view->ops->type,
1375                                    view->lineno + 1,
1376                                    view->lines,
1377                                    lines);
1378
1379                 if (view->pipe) {
1380                         time_t secs = time(NULL) - view->start_time;
1381
1382                         /* Three git seconds are a long time ... */
1383                         if (secs > 2)
1384                                 string_format_from(state, &statelen, " %lds", secs);
1385                 }
1386         }
1387
1388         string_format_from(buf, &bufpos, "[%s]", view->name);
1389         if (*view->ref && bufpos < view->width) {
1390                 size_t refsize = strlen(view->ref);
1391                 size_t minsize = bufpos + 1 + /* abbrev= */ 7 + 1 + statelen;
1392
1393                 if (minsize < view->width)
1394                         refsize = view->width - minsize + 7;
1395                 string_format_from(buf, &bufpos, " %.*s", refsize, view->ref);
1396         }
1397
1398         if (statelen && bufpos < view->width) {
1399                 string_format_from(buf, &bufpos, " %s", state);
1400         }
1401
1402         if (view == display[current_view])
1403                 wbkgdset(view->title, get_line_attr(LINE_TITLE_FOCUS));
1404         else
1405                 wbkgdset(view->title, get_line_attr(LINE_TITLE_BLUR));
1406
1407         mvwaddnstr(view->title, 0, 0, buf, bufpos);
1408         wclrtoeol(view->title);
1409         wmove(view->title, 0, view->width - 1);
1410
1411         if (input_mode)
1412                 wnoutrefresh(view->title);
1413         else
1414                 wrefresh(view->title);
1415 }
1416
1417 static void
1418 resize_display(void)
1419 {
1420         int offset, i;
1421         struct view *base = display[0];
1422         struct view *view = display[1] ? display[1] : display[0];
1423
1424         /* Setup window dimensions */
1425
1426         getmaxyx(stdscr, base->height, base->width);
1427
1428         /* Make room for the status window. */
1429         base->height -= 1;
1430
1431         if (view != base) {
1432                 /* Horizontal split. */
1433                 view->width   = base->width;
1434                 view->height  = SCALE_SPLIT_VIEW(base->height);
1435                 base->height -= view->height;
1436
1437                 /* Make room for the title bar. */
1438                 view->height -= 1;
1439         }
1440
1441         /* Make room for the title bar. */
1442         base->height -= 1;
1443
1444         offset = 0;
1445
1446         foreach_displayed_view (view, i) {
1447                 if (!view->win) {
1448                         view->win = newwin(view->height, 0, offset, 0);
1449                         if (!view->win)
1450                                 die("Failed to create %s view", view->name);
1451
1452                         scrollok(view->win, TRUE);
1453
1454                         view->title = newwin(1, 0, offset + view->height, 0);
1455                         if (!view->title)
1456                                 die("Failed to create title window");
1457
1458                 } else {
1459                         wresize(view->win, view->height, view->width);
1460                         mvwin(view->win,   offset, 0);
1461                         mvwin(view->title, offset + view->height, 0);
1462                 }
1463
1464                 offset += view->height + 1;
1465         }
1466 }
1467
1468 static void
1469 redraw_display(void)
1470 {
1471         struct view *view;
1472         int i;
1473
1474         foreach_displayed_view (view, i) {
1475                 redraw_view(view);
1476                 update_view_title(view);
1477         }
1478 }
1479
1480 static void
1481 update_display_cursor(struct view *view)
1482 {
1483         /* Move the cursor to the right-most column of the cursor line.
1484          *
1485          * XXX: This could turn out to be a bit expensive, but it ensures that
1486          * the cursor does not jump around. */
1487         if (view->lines) {
1488                 wmove(view->win, view->lineno - view->offset, view->width - 1);
1489                 wrefresh(view->win);
1490         }
1491 }
1492
1493 /*
1494  * Navigation
1495  */
1496
1497 /* Scrolling backend */
1498 static void
1499 do_scroll_view(struct view *view, int lines)
1500 {
1501         bool redraw_current_line = FALSE;
1502
1503         /* The rendering expects the new offset. */
1504         view->offset += lines;
1505
1506         assert(0 <= view->offset && view->offset < view->lines);
1507         assert(lines);
1508
1509         /* Move current line into the view. */
1510         if (view->lineno < view->offset) {
1511                 view->lineno = view->offset;
1512                 redraw_current_line = TRUE;
1513         } else if (view->lineno >= view->offset + view->height) {
1514                 view->lineno = view->offset + view->height - 1;
1515                 redraw_current_line = TRUE;
1516         }
1517
1518         assert(view->offset <= view->lineno && view->lineno < view->lines);
1519
1520         /* Redraw the whole screen if scrolling is pointless. */
1521         if (view->height < ABS(lines)) {
1522                 redraw_view(view);
1523
1524         } else {
1525                 int line = lines > 0 ? view->height - lines : 0;
1526                 int end = line + ABS(lines);
1527
1528                 wscrl(view->win, lines);
1529
1530                 for (; line < end; line++) {
1531                         if (!draw_view_line(view, line))
1532                                 break;
1533                 }
1534
1535                 if (redraw_current_line)
1536                         draw_view_line(view, view->lineno - view->offset);
1537         }
1538
1539         redrawwin(view->win);
1540         wrefresh(view->win);
1541         report("");
1542 }
1543
1544 /* Scroll frontend */
1545 static void
1546 scroll_view(struct view *view, enum request request)
1547 {
1548         int lines = 1;
1549
1550         assert(view_is_displayed(view));
1551
1552         switch (request) {
1553         case REQ_SCROLL_PAGE_DOWN:
1554                 lines = view->height;
1555         case REQ_SCROLL_LINE_DOWN:
1556                 if (view->offset + lines > view->lines)
1557                         lines = view->lines - view->offset;
1558
1559                 if (lines == 0 || view->offset + view->height >= view->lines) {
1560                         report("Cannot scroll beyond the last line");
1561                         return;
1562                 }
1563                 break;
1564
1565         case REQ_SCROLL_PAGE_UP:
1566                 lines = view->height;
1567         case REQ_SCROLL_LINE_UP:
1568                 if (lines > view->offset)
1569                         lines = view->offset;
1570
1571                 if (lines == 0) {
1572                         report("Cannot scroll beyond the first line");
1573                         return;
1574                 }
1575
1576                 lines = -lines;
1577                 break;
1578
1579         default:
1580                 die("request %d not handled in switch", request);
1581         }
1582
1583         do_scroll_view(view, lines);
1584 }
1585
1586 /* Cursor moving */
1587 static void
1588 move_view(struct view *view, enum request request)
1589 {
1590         int scroll_steps = 0;
1591         int steps;
1592
1593         switch (request) {
1594         case REQ_MOVE_FIRST_LINE:
1595                 steps = -view->lineno;
1596                 break;
1597
1598         case REQ_MOVE_LAST_LINE:
1599                 steps = view->lines - view->lineno - 1;
1600                 break;
1601
1602         case REQ_MOVE_PAGE_UP:
1603                 steps = view->height > view->lineno
1604                       ? -view->lineno : -view->height;
1605                 break;
1606
1607         case REQ_MOVE_PAGE_DOWN:
1608                 steps = view->lineno + view->height >= view->lines
1609                       ? view->lines - view->lineno - 1 : view->height;
1610                 break;
1611
1612         case REQ_MOVE_UP:
1613                 steps = -1;
1614                 break;
1615
1616         case REQ_MOVE_DOWN:
1617                 steps = 1;
1618                 break;
1619
1620         default:
1621                 die("request %d not handled in switch", request);
1622         }
1623
1624         if (steps <= 0 && view->lineno == 0) {
1625                 report("Cannot move beyond the first line");
1626                 return;
1627
1628         } else if (steps >= 0 && view->lineno + 1 >= view->lines) {
1629                 report("Cannot move beyond the last line");
1630                 return;
1631         }
1632
1633         /* Move the current line */
1634         view->lineno += steps;
1635         assert(0 <= view->lineno && view->lineno < view->lines);
1636
1637         /* Check whether the view needs to be scrolled */
1638         if (view->lineno < view->offset ||
1639             view->lineno >= view->offset + view->height) {
1640                 scroll_steps = steps;
1641                 if (steps < 0 && -steps > view->offset) {
1642                         scroll_steps = -view->offset;
1643
1644                 } else if (steps > 0) {
1645                         if (view->lineno == view->lines - 1 &&
1646                             view->lines > view->height) {
1647                                 scroll_steps = view->lines - view->offset - 1;
1648                                 if (scroll_steps >= view->height)
1649                                         scroll_steps -= view->height - 1;
1650                         }
1651                 }
1652         }
1653
1654         if (!view_is_displayed(view)) {
1655                 view->offset += scroll_steps;
1656                 assert(0 <= view->offset && view->offset < view->lines);
1657                 view->ops->select(view, &view->line[view->lineno]);
1658                 return;
1659         }
1660
1661         /* Repaint the old "current" line if we be scrolling */
1662         if (ABS(steps) < view->height)
1663                 draw_view_line(view, view->lineno - steps - view->offset);
1664
1665         if (scroll_steps) {
1666                 do_scroll_view(view, scroll_steps);
1667                 return;
1668         }
1669
1670         /* Draw the current line */
1671         draw_view_line(view, view->lineno - view->offset);
1672
1673         redrawwin(view->win);
1674         wrefresh(view->win);
1675         report("");
1676 }
1677
1678
1679 /*
1680  * Searching
1681  */
1682
1683 static void search_view(struct view *view, enum request request);
1684
1685 static bool
1686 find_next_line(struct view *view, unsigned long lineno, struct line *line)
1687 {
1688         assert(view_is_displayed(view));
1689
1690         if (!view->ops->grep(view, line))
1691                 return FALSE;
1692
1693         if (lineno - view->offset >= view->height) {
1694                 view->offset = lineno;
1695                 view->lineno = lineno;
1696                 redraw_view(view);
1697
1698         } else {
1699                 unsigned long old_lineno = view->lineno - view->offset;
1700
1701                 view->lineno = lineno;
1702                 draw_view_line(view, old_lineno);
1703
1704                 draw_view_line(view, view->lineno - view->offset);
1705                 redrawwin(view->win);
1706                 wrefresh(view->win);
1707         }
1708
1709         report("Line %ld matches '%s'", lineno + 1, view->grep);
1710         return TRUE;
1711 }
1712
1713 static void
1714 find_next(struct view *view, enum request request)
1715 {
1716         unsigned long lineno = view->lineno;
1717         int direction;
1718
1719         if (!*view->grep) {
1720                 if (!*opt_search)
1721                         report("No previous search");
1722                 else
1723                         search_view(view, request);
1724                 return;
1725         }
1726
1727         switch (request) {
1728         case REQ_SEARCH:
1729         case REQ_FIND_NEXT:
1730                 direction = 1;
1731                 break;
1732
1733         case REQ_SEARCH_BACK:
1734         case REQ_FIND_PREV:
1735                 direction = -1;
1736                 break;
1737
1738         default:
1739                 return;
1740         }
1741
1742         if (request == REQ_FIND_NEXT || request == REQ_FIND_PREV)
1743                 lineno += direction;
1744
1745         /* Note, lineno is unsigned long so will wrap around in which case it
1746          * will become bigger than view->lines. */
1747         for (; lineno < view->lines; lineno += direction) {
1748                 struct line *line = &view->line[lineno];
1749
1750                 if (find_next_line(view, lineno, line))
1751                         return;
1752         }
1753
1754         report("No match found for '%s'", view->grep);
1755 }
1756
1757 static void
1758 search_view(struct view *view, enum request request)
1759 {
1760         int regex_err;
1761
1762         if (view->regex) {
1763                 regfree(view->regex);
1764                 *view->grep = 0;
1765         } else {
1766                 view->regex = calloc(1, sizeof(*view->regex));
1767                 if (!view->regex)
1768                         return;
1769         }
1770
1771         regex_err = regcomp(view->regex, opt_search, REG_EXTENDED);
1772         if (regex_err != 0) {
1773                 char buf[SIZEOF_STR] = "unknown error";
1774
1775                 regerror(regex_err, view->regex, buf, sizeof(buf));
1776                 report("Search failed: %s", buf);
1777                 return;
1778         }
1779
1780         string_copy(view->grep, opt_search);
1781
1782         find_next(view, request);
1783 }
1784
1785 /*
1786  * Incremental updating
1787  */
1788
1789 static void
1790 end_update(struct view *view)
1791 {
1792         if (!view->pipe)
1793                 return;
1794         set_nonblocking_input(FALSE);
1795         if (view->pipe == stdin)
1796                 fclose(view->pipe);
1797         else
1798                 pclose(view->pipe);
1799         view->pipe = NULL;
1800 }
1801
1802 static bool
1803 begin_update(struct view *view)
1804 {
1805         if (view->pipe)
1806                 end_update(view);
1807
1808         if (opt_cmd[0]) {
1809                 string_copy(view->cmd, opt_cmd);
1810                 opt_cmd[0] = 0;
1811                 /* When running random commands, initially show the
1812                  * command in the title. However, it maybe later be
1813                  * overwritten if a commit line is selected. */
1814                 string_copy(view->ref, view->cmd);
1815
1816         } else if (view == VIEW(REQ_VIEW_TREE)) {
1817                 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
1818                 char path[SIZEOF_STR];
1819
1820                 if (strcmp(view->vid, view->id))
1821                         opt_path[0] = path[0] = 0;
1822                 else if (sq_quote(path, 0, opt_path) >= sizeof(path))
1823                         return FALSE;
1824
1825                 if (!string_format(view->cmd, format, view->id, path))
1826                         return FALSE;
1827
1828         } else {
1829                 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
1830                 const char *id = view->id;
1831
1832                 if (!string_format(view->cmd, format, id, id, id, id, id))
1833                         return FALSE;
1834
1835                 /* Put the current ref_* value to the view title ref
1836                  * member. This is needed by the blob view. Most other
1837                  * views sets it automatically after loading because the
1838                  * first line is a commit line. */
1839                 string_copy_rev(view->ref, view->id);
1840         }
1841
1842         /* Special case for the pager view. */
1843         if (opt_pipe) {
1844                 view->pipe = opt_pipe;
1845                 opt_pipe = NULL;
1846         } else {
1847                 view->pipe = popen(view->cmd, "r");
1848         }
1849
1850         if (!view->pipe)
1851                 return FALSE;
1852
1853         set_nonblocking_input(TRUE);
1854
1855         view->offset = 0;
1856         view->lines  = 0;
1857         view->lineno = 0;
1858         string_copy_rev(view->vid, view->id);
1859
1860         if (view->line) {
1861                 int i;
1862
1863                 for (i = 0; i < view->lines; i++)
1864                         if (view->line[i].data)
1865                                 free(view->line[i].data);
1866
1867                 free(view->line);
1868                 view->line = NULL;
1869         }
1870
1871         view->start_time = time(NULL);
1872
1873         return TRUE;
1874 }
1875
1876 static struct line *
1877 realloc_lines(struct view *view, size_t line_size)
1878 {
1879         struct line *tmp = realloc(view->line, sizeof(*view->line) * line_size);
1880
1881         if (!tmp)
1882                 return NULL;
1883
1884         view->line = tmp;
1885         view->line_size = line_size;
1886         return view->line;
1887 }
1888
1889 static bool
1890 update_view(struct view *view)
1891 {
1892         char in_buffer[BUFSIZ];
1893         char out_buffer[BUFSIZ * 2];
1894         char *line;
1895         /* The number of lines to read. If too low it will cause too much
1896          * redrawing (and possible flickering), if too high responsiveness
1897          * will suffer. */
1898         unsigned long lines = view->height;
1899         int redraw_from = -1;
1900
1901         if (!view->pipe)
1902                 return TRUE;
1903
1904         /* Only redraw if lines are visible. */
1905         if (view->offset + view->height >= view->lines)
1906                 redraw_from = view->lines - view->offset;
1907
1908         /* FIXME: This is probably not perfect for backgrounded views. */
1909         if (!realloc_lines(view, view->lines + lines))
1910                 goto alloc_error;
1911
1912         while ((line = fgets(in_buffer, sizeof(in_buffer), view->pipe))) {
1913                 size_t linelen = strlen(line);
1914
1915                 if (linelen)
1916                         line[linelen - 1] = 0;
1917
1918                 if (opt_iconv != ICONV_NONE) {
1919                         char *inbuf = line;
1920                         size_t inlen = linelen;
1921
1922                         char *outbuf = out_buffer;
1923                         size_t outlen = sizeof(out_buffer);
1924
1925                         size_t ret;
1926
1927                         ret = iconv(opt_iconv, &inbuf, &inlen, &outbuf, &outlen);
1928                         if (ret != (size_t) -1) {
1929                                 line = out_buffer;
1930                                 linelen = strlen(out_buffer);
1931                         }
1932                 }
1933
1934                 if (!view->ops->read(view, line))
1935                         goto alloc_error;
1936
1937                 if (lines-- == 1)
1938                         break;
1939         }
1940
1941         {
1942                 int digits;
1943
1944                 lines = view->lines;
1945                 for (digits = 0; lines; digits++)
1946                         lines /= 10;
1947
1948                 /* Keep the displayed view in sync with line number scaling. */
1949                 if (digits != view->digits) {
1950                         view->digits = digits;
1951                         redraw_from = 0;
1952                 }
1953         }
1954
1955         if (!view_is_displayed(view))
1956                 goto check_pipe;
1957
1958         if (view == VIEW(REQ_VIEW_TREE)) {
1959                 /* Clear the view and redraw everything since the tree sorting
1960                  * might have rearranged things. */
1961                 redraw_view(view);
1962
1963         } else if (redraw_from >= 0) {
1964                 /* If this is an incremental update, redraw the previous line
1965                  * since for commits some members could have changed when
1966                  * loading the main view. */
1967                 if (redraw_from > 0)
1968                         redraw_from--;
1969
1970                 /* Since revision graph visualization requires knowledge
1971                  * about the parent commit, it causes a further one-off
1972                  * needed to be redrawn for incremental updates. */
1973                 if (redraw_from > 0 && opt_rev_graph)
1974                         redraw_from--;
1975
1976                 /* Incrementally draw avoids flickering. */
1977                 redraw_view_from(view, redraw_from);
1978         }
1979
1980         /* Update the title _after_ the redraw so that if the redraw picks up a
1981          * commit reference in view->ref it'll be available here. */
1982         update_view_title(view);
1983
1984 check_pipe:
1985         if (ferror(view->pipe)) {
1986                 report("Failed to read: %s", strerror(errno));
1987                 goto end;
1988
1989         } else if (feof(view->pipe)) {
1990                 report("");
1991                 goto end;
1992         }
1993
1994         return TRUE;
1995
1996 alloc_error:
1997         report("Allocation failure");
1998
1999 end:
2000         view->ops->read(view, NULL);
2001         end_update(view);
2002         return FALSE;
2003 }
2004
2005 static struct line *
2006 add_line_data(struct view *view, void *data, enum line_type type)
2007 {
2008         struct line *line = &view->line[view->lines++];
2009
2010         memset(line, 0, sizeof(*line));
2011         line->type = type;
2012         line->data = data;
2013
2014         return line;
2015 }
2016
2017 static struct line *
2018 add_line_text(struct view *view, char *data, enum line_type type)
2019 {
2020         if (data)
2021                 data = strdup(data);
2022
2023         return data ? add_line_data(view, data, type) : NULL;
2024 }
2025
2026
2027 /*
2028  * View opening
2029  */
2030
2031 enum open_flags {
2032         OPEN_DEFAULT = 0,       /* Use default view switching. */
2033         OPEN_SPLIT = 1,         /* Split current view. */
2034         OPEN_BACKGROUNDED = 2,  /* Backgrounded. */
2035         OPEN_RELOAD = 4,        /* Reload view even if it is the current. */
2036 };
2037
2038 static void
2039 open_view(struct view *prev, enum request request, enum open_flags flags)
2040 {
2041         bool backgrounded = !!(flags & OPEN_BACKGROUNDED);
2042         bool split = !!(flags & OPEN_SPLIT);
2043         bool reload = !!(flags & OPEN_RELOAD);
2044         struct view *view = VIEW(request);
2045         int nviews = displayed_views();
2046         struct view *base_view = display[0];
2047
2048         if (view == prev && nviews == 1 && !reload) {
2049                 report("Already in %s view", view->name);
2050                 return;
2051         }
2052
2053         if (view->ops->open) {
2054                 if (!view->ops->open(view)) {
2055                         report("Failed to load %s view", view->name);
2056                         return;
2057                 }
2058
2059         } else if ((reload || strcmp(view->vid, view->id)) &&
2060                    !begin_update(view)) {
2061                 report("Failed to load %s view", view->name);
2062                 return;
2063         }
2064
2065         if (split) {
2066                 display[1] = view;
2067                 if (!backgrounded)
2068                         current_view = 1;
2069         } else {
2070                 /* Maximize the current view. */
2071                 memset(display, 0, sizeof(display));
2072                 current_view = 0;
2073                 display[current_view] = view;
2074         }
2075
2076         /* Resize the view when switching between split- and full-screen,
2077          * or when switching between two different full-screen views. */
2078         if (nviews != displayed_views() ||
2079             (nviews == 1 && base_view != display[0]))
2080                 resize_display();
2081
2082         if (split && prev->lineno - prev->offset >= prev->height) {
2083                 /* Take the title line into account. */
2084                 int lines = prev->lineno - prev->offset - prev->height + 1;
2085
2086                 /* Scroll the view that was split if the current line is
2087                  * outside the new limited view. */
2088                 do_scroll_view(prev, lines);
2089         }
2090
2091         if (prev && view != prev) {
2092                 if (split && !backgrounded) {
2093                         /* "Blur" the previous view. */
2094                         update_view_title(prev);
2095                 }
2096
2097                 view->parent = prev;
2098         }
2099
2100         if (view->pipe && view->lines == 0) {
2101                 /* Clear the old view and let the incremental updating refill
2102                  * the screen. */
2103                 wclear(view->win);
2104                 report("");
2105         } else {
2106                 redraw_view(view);
2107                 report("");
2108         }
2109
2110         /* If the view is backgrounded the above calls to report()
2111          * won't redraw the view title. */
2112         if (backgrounded)
2113                 update_view_title(view);
2114 }
2115
2116
2117 /*
2118  * User request switch noodle
2119  */
2120
2121 static int
2122 view_driver(struct view *view, enum request request)
2123 {
2124         int i;
2125
2126         switch (request) {
2127         case REQ_MOVE_UP:
2128         case REQ_MOVE_DOWN:
2129         case REQ_MOVE_PAGE_UP:
2130         case REQ_MOVE_PAGE_DOWN:
2131         case REQ_MOVE_FIRST_LINE:
2132         case REQ_MOVE_LAST_LINE:
2133                 move_view(view, request);
2134                 break;
2135
2136         case REQ_SCROLL_LINE_DOWN:
2137         case REQ_SCROLL_LINE_UP:
2138         case REQ_SCROLL_PAGE_DOWN:
2139         case REQ_SCROLL_PAGE_UP:
2140                 scroll_view(view, request);
2141                 break;
2142
2143         case REQ_VIEW_BLOB:
2144                 if (!ref_blob[0]) {
2145                         report("No file chosen, press %s to open tree view",
2146                                get_key(REQ_VIEW_TREE));
2147                         break;
2148                 }
2149                 open_view(view, request, OPEN_DEFAULT);
2150                 break;
2151
2152         case REQ_VIEW_PAGER:
2153                 if (!VIEW(REQ_VIEW_PAGER)->lines) {
2154                         report("No pager content, press %s to run command from prompt",
2155                                get_key(REQ_PROMPT));
2156                         break;
2157                 }
2158                 open_view(view, request, OPEN_DEFAULT);
2159                 break;
2160
2161         case REQ_VIEW_MAIN:
2162         case REQ_VIEW_DIFF:
2163         case REQ_VIEW_LOG:
2164         case REQ_VIEW_TREE:
2165         case REQ_VIEW_HELP:
2166         case REQ_VIEW_STATUS:
2167                 open_view(view, request, OPEN_DEFAULT);
2168                 break;
2169
2170         case REQ_NEXT:
2171         case REQ_PREVIOUS:
2172                 request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
2173
2174                 if ((view == VIEW(REQ_VIEW_DIFF) &&
2175                      view->parent == VIEW(REQ_VIEW_MAIN)) ||
2176                    (view == VIEW(REQ_VIEW_BLOB) &&
2177                      view->parent == VIEW(REQ_VIEW_TREE))) {
2178                         view = view->parent;
2179                         move_view(view, request);
2180                         if (view_is_displayed(view))
2181                                 update_view_title(view);
2182                 } else {
2183                         move_view(view, request);
2184                         break;
2185                 }
2186                 /* Fall-through */
2187
2188         case REQ_ENTER:
2189                 if (!view->lines) {
2190                         report("Nothing to enter");
2191                         break;
2192                 }
2193                 return view->ops->enter(view, &view->line[view->lineno]);
2194
2195         case REQ_VIEW_NEXT:
2196         {
2197                 int nviews = displayed_views();
2198                 int next_view = (current_view + 1) % nviews;
2199
2200                 if (next_view == current_view) {
2201                         report("Only one view is displayed");
2202                         break;
2203                 }
2204
2205                 current_view = next_view;
2206                 /* Blur out the title of the previous view. */
2207                 update_view_title(view);
2208                 report("");
2209                 break;
2210         }
2211         case REQ_TOGGLE_LINENO:
2212                 opt_line_number = !opt_line_number;
2213                 redraw_display();
2214                 break;
2215
2216         case REQ_TOGGLE_REV_GRAPH:
2217                 opt_rev_graph = !opt_rev_graph;
2218                 redraw_display();
2219                 break;
2220
2221         case REQ_PROMPT:
2222                 /* Always reload^Wrerun commands from the prompt. */
2223                 open_view(view, opt_request, OPEN_RELOAD);
2224                 break;
2225
2226         case REQ_SEARCH:
2227         case REQ_SEARCH_BACK:
2228                 search_view(view, request);
2229                 break;
2230
2231         case REQ_FIND_NEXT:
2232         case REQ_FIND_PREV:
2233                 find_next(view, request);
2234                 break;
2235
2236         case REQ_STOP_LOADING:
2237                 for (i = 0; i < ARRAY_SIZE(views); i++) {
2238                         view = &views[i];
2239                         if (view->pipe)
2240                                 report("Stopped loading the %s view", view->name),
2241                         end_update(view);
2242                 }
2243                 break;
2244
2245         case REQ_SHOW_VERSION:
2246                 report("tig-%s (built %s)", VERSION, __DATE__);
2247                 return TRUE;
2248
2249         case REQ_SCREEN_RESIZE:
2250                 resize_display();
2251                 /* Fall-through */
2252         case REQ_SCREEN_REDRAW:
2253                 redraw_display();
2254                 break;
2255
2256         case REQ_NONE:
2257                 doupdate();
2258                 return TRUE;
2259
2260         case REQ_VIEW_CLOSE:
2261                 /* XXX: Mark closed views by letting view->parent point to the
2262                  * view itself. Parents to closed view should never be
2263                  * followed. */
2264                 if (view->parent &&
2265                     view->parent->parent != view->parent) {
2266                         memset(display, 0, sizeof(display));
2267                         current_view = 0;
2268                         display[current_view] = view->parent;
2269                         view->parent = view;
2270                         resize_display();
2271                         redraw_display();
2272                         break;
2273                 }
2274                 /* Fall-through */
2275         case REQ_QUIT:
2276                 return FALSE;
2277
2278         default:
2279                 /* An unknown key will show most commonly used commands. */
2280                 report("Unknown key, press 'h' for help");
2281                 return TRUE;
2282         }
2283
2284         return TRUE;
2285 }
2286
2287
2288 /*
2289  * Pager backend
2290  */
2291
2292 static bool
2293 pager_draw(struct view *view, struct line *line, unsigned int lineno, bool selected)
2294 {
2295         char *text = line->data;
2296         enum line_type type = line->type;
2297         int textlen = strlen(text);
2298         int attr;
2299
2300         wmove(view->win, lineno, 0);
2301
2302         if (selected) {
2303                 type = LINE_CURSOR;
2304                 wchgat(view->win, -1, 0, type, NULL);
2305         }
2306
2307         attr = get_line_attr(type);
2308         wattrset(view->win, attr);
2309
2310         if (opt_line_number || opt_tab_size < TABSIZE) {
2311                 static char spaces[] = "                    ";
2312                 int col_offset = 0, col = 0;
2313
2314                 if (opt_line_number) {
2315                         unsigned long real_lineno = view->offset + lineno + 1;
2316
2317                         if (real_lineno == 1 ||
2318                             (real_lineno % opt_num_interval) == 0) {
2319                                 wprintw(view->win, "%.*d", view->digits, real_lineno);
2320
2321                         } else {
2322                                 waddnstr(view->win, spaces,
2323                                          MIN(view->digits, STRING_SIZE(spaces)));
2324                         }
2325                         waddstr(view->win, ": ");
2326                         col_offset = view->digits + 2;
2327                 }
2328
2329                 while (text && col_offset + col < view->width) {
2330                         int cols_max = view->width - col_offset - col;
2331                         char *pos = text;
2332                         int cols;
2333
2334                         if (*text == '\t') {
2335                                 text++;
2336                                 assert(sizeof(spaces) > TABSIZE);
2337                                 pos = spaces;
2338                                 cols = opt_tab_size - (col % opt_tab_size);
2339
2340                         } else {
2341                                 text = strchr(text, '\t');
2342                                 cols = line ? text - pos : strlen(pos);
2343                         }
2344
2345                         waddnstr(view->win, pos, MIN(cols, cols_max));
2346                         col += cols;
2347                 }
2348
2349         } else {
2350                 int col = 0, pos = 0;
2351
2352                 for (; pos < textlen && col < view->width; pos++, col++)
2353                         if (text[pos] == '\t')
2354                                 col += TABSIZE - (col % TABSIZE) - 1;
2355
2356                 waddnstr(view->win, text, pos);
2357         }
2358
2359         return TRUE;
2360 }
2361
2362 static bool
2363 add_describe_ref(char *buf, size_t *bufpos, char *commit_id, const char *sep)
2364 {
2365         char refbuf[SIZEOF_STR];
2366         char *ref = NULL;
2367         FILE *pipe;
2368
2369         if (!string_format(refbuf, "git describe %s 2>/dev/null", commit_id))
2370                 return TRUE;
2371
2372         pipe = popen(refbuf, "r");
2373         if (!pipe)
2374                 return TRUE;
2375
2376         if ((ref = fgets(refbuf, sizeof(refbuf), pipe)))
2377                 ref = chomp_string(ref);
2378         pclose(pipe);
2379
2380         if (!ref || !*ref)
2381                 return TRUE;
2382
2383         /* This is the only fatal call, since it can "corrupt" the buffer. */
2384         if (!string_nformat(buf, SIZEOF_STR, bufpos, "%s%s", sep, ref))
2385                 return FALSE;
2386
2387         return TRUE;
2388 }
2389
2390 static void
2391 add_pager_refs(struct view *view, struct line *line)
2392 {
2393         char buf[SIZEOF_STR];
2394         char *commit_id = line->data + STRING_SIZE("commit ");
2395         struct ref **refs;
2396         size_t bufpos = 0, refpos = 0;
2397         const char *sep = "Refs: ";
2398         bool is_tag = FALSE;
2399
2400         assert(line->type == LINE_COMMIT);
2401
2402         refs = get_refs(commit_id);
2403         if (!refs) {
2404                 if (view == VIEW(REQ_VIEW_DIFF))
2405                         goto try_add_describe_ref;
2406                 return;
2407         }
2408
2409         do {
2410                 struct ref *ref = refs[refpos];
2411                 char *fmt = ref->tag    ? "%s[%s]" :
2412                             ref->remote ? "%s<%s>" : "%s%s";
2413
2414                 if (!string_format_from(buf, &bufpos, fmt, sep, ref->name))
2415                         return;
2416                 sep = ", ";
2417                 if (ref->tag)
2418                         is_tag = TRUE;
2419         } while (refs[refpos++]->next);
2420
2421         if (!is_tag && view == VIEW(REQ_VIEW_DIFF)) {
2422 try_add_describe_ref:
2423                 /* Add <tag>-g<commit_id> "fake" reference. */
2424                 if (!add_describe_ref(buf, &bufpos, commit_id, sep))
2425                         return;
2426         }
2427
2428         if (bufpos == 0)
2429                 return;
2430
2431         if (!realloc_lines(view, view->line_size + 1))
2432                 return;
2433
2434         add_line_text(view, buf, LINE_PP_REFS);
2435 }
2436
2437 static bool
2438 pager_read(struct view *view, char *data)
2439 {
2440         struct line *line;
2441
2442         if (!data)
2443                 return TRUE;
2444
2445         line = add_line_text(view, data, get_line_type(data));
2446         if (!line)
2447                 return FALSE;
2448
2449         if (line->type == LINE_COMMIT &&
2450             (view == VIEW(REQ_VIEW_DIFF) ||
2451              view == VIEW(REQ_VIEW_LOG)))
2452                 add_pager_refs(view, line);
2453
2454         return TRUE;
2455 }
2456
2457 static bool
2458 pager_enter(struct view *view, struct line *line)
2459 {
2460         int split = 0;
2461
2462         if (line->type == LINE_COMMIT &&
2463            (view == VIEW(REQ_VIEW_LOG) ||
2464             view == VIEW(REQ_VIEW_PAGER))) {
2465                 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
2466                 split = 1;
2467         }
2468
2469         /* Always scroll the view even if it was split. That way
2470          * you can use Enter to scroll through the log view and
2471          * split open each commit diff. */
2472         scroll_view(view, REQ_SCROLL_LINE_DOWN);
2473
2474         /* FIXME: A minor workaround. Scrolling the view will call report("")
2475          * but if we are scrolling a non-current view this won't properly
2476          * update the view title. */
2477         if (split)
2478                 update_view_title(view);
2479
2480         return TRUE;
2481 }
2482
2483 static bool
2484 pager_grep(struct view *view, struct line *line)
2485 {
2486         regmatch_t pmatch;
2487         char *text = line->data;
2488
2489         if (!*text)
2490                 return FALSE;
2491
2492         if (regexec(view->regex, text, 1, &pmatch, 0) == REG_NOMATCH)
2493                 return FALSE;
2494
2495         return TRUE;
2496 }
2497
2498 static void
2499 pager_select(struct view *view, struct line *line)
2500 {
2501         if (line->type == LINE_COMMIT) {
2502                 char *text = line->data + STRING_SIZE("commit ");
2503
2504                 if (view != VIEW(REQ_VIEW_PAGER))
2505                         string_copy_rev(view->ref, text);
2506                 string_copy_rev(ref_commit, text);
2507         }
2508 }
2509
2510 static struct view_ops pager_ops = {
2511         "line",
2512         NULL,
2513         pager_read,
2514         pager_draw,
2515         pager_enter,
2516         pager_grep,
2517         pager_select,
2518 };
2519
2520
2521 /*
2522  * Help backend
2523  */
2524
2525 static bool
2526 help_open(struct view *view)
2527 {
2528         char buf[BUFSIZ];
2529         int lines = ARRAY_SIZE(req_info) + 2;
2530         int i;
2531
2532         if (view->lines > 0)
2533                 return TRUE;
2534
2535         for (i = 0; i < ARRAY_SIZE(req_info); i++)
2536                 if (!req_info[i].request)
2537                         lines++;
2538
2539         view->line = calloc(lines, sizeof(*view->line));
2540         if (!view->line)
2541                 return FALSE;
2542
2543         add_line_text(view, "Quick reference for tig keybindings:", LINE_DEFAULT);
2544
2545         for (i = 0; i < ARRAY_SIZE(req_info); i++) {
2546                 char *key;
2547
2548                 if (!req_info[i].request) {
2549                         add_line_text(view, "", LINE_DEFAULT);
2550                         add_line_text(view, req_info[i].help, LINE_DEFAULT);
2551                         continue;
2552                 }
2553
2554                 key = get_key(req_info[i].request);
2555                 if (!string_format(buf, "    %-25s %s", key, req_info[i].help))
2556                         continue;
2557
2558                 add_line_text(view, buf, LINE_DEFAULT);
2559         }
2560
2561         return TRUE;
2562 }
2563
2564 static struct view_ops help_ops = {
2565         "line",
2566         help_open,
2567         NULL,
2568         pager_draw,
2569         pager_enter,
2570         pager_grep,
2571         pager_select,
2572 };
2573
2574
2575 /*
2576  * Tree backend
2577  */
2578
2579 /* Parse output from git-ls-tree(1):
2580  *
2581  * 100644 blob fb0e31ea6cc679b7379631188190e975f5789c26 Makefile
2582  * 100644 blob 5304ca4260aaddaee6498f9630e7d471b8591ea6 README
2583  * 100644 blob f931e1d229c3e185caad4449bf5b66ed72462657 tig.c
2584  * 100644 blob ed09fe897f3c7c9af90bcf80cae92558ea88ae38 web.conf
2585  */
2586
2587 #define SIZEOF_TREE_ATTR \
2588         STRING_SIZE("100644 blob ed09fe897f3c7c9af90bcf80cae92558ea88ae38\t")
2589
2590 #define TREE_UP_FORMAT "040000 tree %s\t.."
2591
2592 static int
2593 tree_compare_entry(enum line_type type1, char *name1,
2594                    enum line_type type2, char *name2)
2595 {
2596         if (type1 != type2) {
2597                 if (type1 == LINE_TREE_DIR)
2598                         return -1;
2599                 return 1;
2600         }
2601
2602         return strcmp(name1, name2);
2603 }
2604
2605 static bool
2606 tree_read(struct view *view, char *text)
2607 {
2608         size_t textlen = text ? strlen(text) : 0;
2609         char buf[SIZEOF_STR];
2610         unsigned long pos;
2611         enum line_type type;
2612         bool first_read = view->lines == 0;
2613
2614         if (textlen <= SIZEOF_TREE_ATTR)
2615                 return FALSE;
2616
2617         type = text[STRING_SIZE("100644 ")] == 't'
2618              ? LINE_TREE_DIR : LINE_TREE_FILE;
2619
2620         if (first_read) {
2621                 /* Add path info line */
2622                 if (!string_format(buf, "Directory path /%s", opt_path) ||
2623                     !realloc_lines(view, view->line_size + 1) ||
2624                     !add_line_text(view, buf, LINE_DEFAULT))
2625                         return FALSE;
2626
2627                 /* Insert "link" to parent directory. */
2628                 if (*opt_path) {
2629                         if (!string_format(buf, TREE_UP_FORMAT, view->ref) ||
2630                             !realloc_lines(view, view->line_size + 1) ||
2631                             !add_line_text(view, buf, LINE_TREE_DIR))
2632                                 return FALSE;
2633                 }
2634         }
2635
2636         /* Strip the path part ... */
2637         if (*opt_path) {
2638                 size_t pathlen = textlen - SIZEOF_TREE_ATTR;
2639                 size_t striplen = strlen(opt_path);
2640                 char *path = text + SIZEOF_TREE_ATTR;
2641
2642                 if (pathlen > striplen)
2643                         memmove(path, path + striplen,
2644                                 pathlen - striplen + 1);
2645         }
2646
2647         /* Skip "Directory ..." and ".." line. */
2648         for (pos = 1 + !!*opt_path; pos < view->lines; pos++) {
2649                 struct line *line = &view->line[pos];
2650                 char *path1 = ((char *) line->data) + SIZEOF_TREE_ATTR;
2651                 char *path2 = text + SIZEOF_TREE_ATTR;
2652                 int cmp = tree_compare_entry(line->type, path1, type, path2);
2653
2654                 if (cmp <= 0)
2655                         continue;
2656
2657                 text = strdup(text);
2658                 if (!text)
2659                         return FALSE;
2660
2661                 if (view->lines > pos)
2662                         memmove(&view->line[pos + 1], &view->line[pos],
2663                                 (view->lines - pos) * sizeof(*line));
2664
2665                 line = &view->line[pos];
2666                 line->data = text;
2667                 line->type = type;
2668                 view->lines++;
2669                 return TRUE;
2670         }
2671
2672         if (!add_line_text(view, text, type))
2673                 return FALSE;
2674
2675         /* Move the current line to the first tree entry. */
2676         if (first_read)
2677                 view->lineno++;
2678
2679         return TRUE;
2680 }
2681
2682 static bool
2683 tree_enter(struct view *view, struct line *line)
2684 {
2685         enum open_flags flags;
2686         enum request request;
2687
2688         switch (line->type) {
2689         case LINE_TREE_DIR:
2690                 /* Depending on whether it is a subdir or parent (updir?) link
2691                  * mangle the path buffer. */
2692                 if (line == &view->line[1] && *opt_path) {
2693                         size_t path_len = strlen(opt_path);
2694                         char *dirsep = opt_path + path_len - 1;
2695
2696                         while (dirsep > opt_path && dirsep[-1] != '/')
2697                                 dirsep--;
2698
2699                         dirsep[0] = 0;
2700
2701                 } else {
2702                         size_t pathlen = strlen(opt_path);
2703                         size_t origlen = pathlen;
2704                         char *data = line->data;
2705                         char *basename = data + SIZEOF_TREE_ATTR;
2706
2707                         if (!string_format_from(opt_path, &pathlen, "%s/", basename)) {
2708                                 opt_path[origlen] = 0;
2709                                 return TRUE;
2710                         }
2711                 }
2712
2713                 /* Trees and subtrees share the same ID, so they are not not
2714                  * unique like blobs. */
2715                 flags = OPEN_RELOAD;
2716                 request = REQ_VIEW_TREE;
2717                 break;
2718
2719         case LINE_TREE_FILE:
2720                 flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
2721                 request = REQ_VIEW_BLOB;
2722                 break;
2723
2724         default:
2725                 return TRUE;
2726         }
2727
2728         open_view(view, request, flags);
2729
2730         return TRUE;
2731 }
2732
2733 static void
2734 tree_select(struct view *view, struct line *line)
2735 {
2736         char *text = line->data + STRING_SIZE("100644 blob ");
2737
2738         if (line->type == LINE_TREE_FILE) {
2739                 string_copy_rev(ref_blob, text);
2740
2741         } else if (line->type != LINE_TREE_DIR) {
2742                 return;
2743         }
2744
2745         string_copy_rev(view->ref, text);
2746 }
2747
2748 static struct view_ops tree_ops = {
2749         "file",
2750         NULL,
2751         tree_read,
2752         pager_draw,
2753         tree_enter,
2754         pager_grep,
2755         tree_select,
2756 };
2757
2758 static bool
2759 blob_read(struct view *view, char *line)
2760 {
2761         return add_line_text(view, line, LINE_DEFAULT);
2762 }
2763
2764 static struct view_ops blob_ops = {
2765         "line",
2766         NULL,
2767         blob_read,
2768         pager_draw,
2769         pager_enter,
2770         pager_grep,
2771         pager_select,
2772 };
2773
2774
2775 /*
2776  * Status backend
2777  */
2778
2779 struct status {
2780         char status;
2781         struct {
2782                 mode_t mode;
2783                 char rev[SIZEOF_REV];
2784         } old;
2785         struct {
2786                 mode_t mode;
2787                 char rev[SIZEOF_REV];
2788         } new;
2789         char name[SIZEOF_STR];
2790 };
2791
2792 /* Get fields from the diff line:
2793  * :100644 100644 06a5d6ae9eca55be2e0e585a152e6b1336f2b20e 0000000000000000000000000000000000000000 M
2794  */
2795 static inline bool
2796 status_get_diff(struct status *file, char *buf, size_t bufsize)
2797 {
2798         char *old_mode = buf +  1;
2799         char *new_mode = buf +  8;
2800         char *old_rev  = buf + 15;
2801         char *new_rev  = buf + 56;
2802         char *status   = buf + 97;
2803
2804         if (bufsize != 99 ||
2805             old_mode[-1] != ':' ||
2806             new_mode[-1] != ' ' ||
2807             old_rev[-1]  != ' ' ||
2808             new_rev[-1]  != ' ' ||
2809             status[-1]   != ' ')
2810                 return FALSE;
2811
2812         file->status = *status;
2813
2814         string_copy_rev(file->old.rev, old_rev);
2815         string_copy_rev(file->new.rev, new_rev);
2816
2817         file->old.mode = strtoul(old_mode, NULL, 8);
2818         file->new.mode = strtoul(new_mode, NULL, 8);
2819
2820         file->name[0] = 0;
2821
2822         return TRUE;
2823 }
2824
2825 static bool
2826 status_run(struct view *view, const char cmd[], bool diff, enum line_type type)
2827 {
2828         struct status *file = NULL;
2829         char buf[SIZEOF_STR * 4];
2830         size_t bufsize = 0;
2831         FILE *pipe;
2832
2833         pipe = popen(cmd, "r");
2834         if (!pipe)
2835                 return FALSE;
2836
2837         add_line_data(view, NULL, type);
2838
2839         while (!feof(pipe) && !ferror(pipe)) {
2840                 char *sep;
2841                 size_t readsize;
2842
2843                 readsize = fread(buf + bufsize, 1, sizeof(buf) - bufsize, pipe);
2844                 if (!readsize)
2845                         break;
2846                 bufsize += readsize;
2847
2848                 /* Process while we have NUL chars. */
2849                 while ((sep = memchr(buf, 0, bufsize))) {
2850                         size_t sepsize = sep - buf + 1;
2851
2852                         if (!file) {
2853                                 if (!realloc_lines(view, view->line_size + 1))
2854                                         goto error_out;
2855
2856                                 file = calloc(1, sizeof(*file));
2857                                 if (!file)
2858                                         goto error_out;
2859
2860                                 add_line_data(view, file, type);
2861                         }
2862
2863                         /* Parse diff info part. */
2864                         if (!diff) {
2865                                 file->status = '?';
2866
2867                         } else if (!file->status) {
2868                                 if (!status_get_diff(file, buf, sepsize))
2869                                         goto error_out;
2870
2871                                 bufsize -= sepsize;
2872                                 memmove(buf, sep + 1, bufsize);
2873
2874                                 sep = memchr(buf, 0, bufsize);
2875                                 if (!sep)
2876                                         break;
2877                                 sepsize = sep - buf + 1;
2878                         }
2879
2880                         /* git-ls-files just delivers a NUL separated
2881                          * list of file names similar to the second half
2882                          * of the git-diff-* output. */
2883                         string_ncopy(file->name, buf, sepsize);
2884                         bufsize -= sepsize;
2885                         memmove(buf, sep + 1, bufsize);
2886                         file = NULL;
2887                 }
2888         }
2889
2890         if (ferror(pipe)) {
2891 error_out:
2892                 pclose(pipe);
2893                 return FALSE;
2894         }
2895
2896         if (!view->line[view->lines - 1].data)
2897                 add_line_data(view, NULL, LINE_STAT_NONE);
2898
2899         pclose(pipe);
2900         return TRUE;
2901 }
2902
2903 #define STATUS_DIFF_INDEX_CMD "git diff-index -z --cached HEAD"
2904 #define STATUS_DIFF_FILES_CMD "git diff-files -z"
2905 #define STATUS_LIST_OTHER_CMD \
2906         "_git_exclude=$(git rev-parse --git-dir)/info/exclude;" \
2907         "test -f \"$_git_exclude\" && exclude=\"--exclude-from=$_git_exclude\";" \
2908         "git ls-files -z --others --exclude-per-directory=.gitignore \"$exclude\"" \
2909
2910 /* First parse staged info using git-diff-index(1), then parse unstaged
2911  * info using git-diff-files(1), and finally untracked files using
2912  * git-ls-files(1). */
2913 static bool
2914 status_open(struct view *view)
2915 {
2916         size_t i;
2917
2918         for (i = 0; i < view->lines; i++)
2919                 free(view->line[i].data);
2920         free(view->line);
2921         view->lines = view->line_size = 0;
2922         view->line = NULL;
2923
2924         if (!realloc_lines(view, view->line_size + 6))
2925                 return FALSE;
2926
2927         if (!status_run(view, STATUS_DIFF_INDEX_CMD, TRUE, LINE_STAT_STAGED) ||
2928             !status_run(view, STATUS_DIFF_FILES_CMD, TRUE, LINE_STAT_UNSTAGED) ||
2929             !status_run(view, STATUS_LIST_OTHER_CMD, FALSE, LINE_STAT_UNTRACKED))
2930                 return FALSE;
2931
2932         return TRUE;
2933 }
2934
2935 static bool
2936 status_draw(struct view *view, struct line *line, unsigned int lineno, bool selected)
2937 {
2938         struct status *status = line->data;
2939
2940         wmove(view->win, lineno, 0);
2941
2942         if (selected) {
2943                 wattrset(view->win, get_line_attr(LINE_CURSOR));
2944                 wchgat(view->win, -1, 0, LINE_CURSOR, NULL);
2945
2946         } else if (!status && line->type != LINE_STAT_NONE) {
2947                 wattrset(view->win, get_line_attr(LINE_STAT_SECTION));
2948                 wchgat(view->win, -1, 0, LINE_STAT_SECTION, NULL);
2949
2950         } else {
2951                 wattrset(view->win, get_line_attr(line->type));
2952         }
2953
2954         if (!status) {
2955                 char *text;
2956
2957                 switch (line->type) {
2958                 case LINE_STAT_STAGED:
2959                         text = "Changes to be committed:";
2960                         break;
2961
2962                 case LINE_STAT_UNSTAGED:
2963                         text = "Changed but not updated:";
2964                         break;
2965
2966                 case LINE_STAT_UNTRACKED:
2967                         text = "Untracked files:";
2968                         break;
2969
2970                 case LINE_STAT_NONE:
2971                         text = "    (no files)";
2972                         break;
2973
2974                 default:
2975                         return FALSE;
2976                 }
2977
2978                 waddstr(view->win, text);
2979                 return TRUE;
2980         }
2981
2982         waddch(view->win, status->status);
2983         if (!selected)
2984                 wattrset(view->win, A_NORMAL);
2985         wmove(view->win, lineno, 4);
2986         waddstr(view->win, status->name);
2987
2988         return TRUE;
2989 }
2990
2991 static bool
2992 status_enter(struct view *view, struct line *line)
2993 {
2994         struct status *status = line->data;
2995         char cmd[SIZEOF_STR];
2996         char buf[SIZEOF_STR];
2997         size_t cmdsize = 0;
2998         size_t bufsize = 0;
2999         size_t written = 0;
3000         FILE *pipe;
3001
3002         if (!status)
3003                 return TRUE;
3004
3005         if (opt_cdup[0] &&
3006             line->type != LINE_STAT_UNTRACKED &&
3007             !string_format_from(cmd, &cmdsize, "cd %s;", opt_cdup))
3008                 return FALSE;
3009
3010         switch (line->type) {
3011         case LINE_STAT_STAGED:
3012                 if (!string_format_from(buf, &bufsize, "%06o %s\t%s%c",
3013                                         status->old.mode,
3014                                         status->old.rev,
3015                                         status->name, 0))
3016                         return FALSE;
3017
3018                 string_add(cmd, cmdsize, "git update-index -z --index-info");
3019                 break;
3020
3021         case LINE_STAT_UNSTAGED:
3022         case LINE_STAT_UNTRACKED:
3023                 if (!string_format_from(buf, &bufsize, "%s%c", status->name, 0))
3024                         return FALSE;
3025
3026                 string_add(cmd, cmdsize, "git update-index -z --add --remove --stdin");
3027                 break;
3028
3029         default:
3030                 die("w00t");
3031         }
3032
3033         pipe = popen(cmd, "w");
3034         if (!pipe)
3035                 return FALSE;
3036
3037         while (!ferror(pipe) && written < bufsize) {
3038                 written += fwrite(buf + written, 1, bufsize - written, pipe);
3039         }
3040
3041         pclose(pipe);
3042
3043         if (written != bufsize)
3044                 return FALSE;
3045
3046         open_view(view, REQ_VIEW_STATUS, OPEN_RELOAD);
3047         return TRUE;
3048 }
3049
3050 static void
3051 status_select(struct view *view, struct line *line)
3052 {
3053         char *text;
3054
3055         switch (line->type) {
3056         case LINE_STAT_STAGED:
3057                 text = "Press Enter to unstage file for commit";
3058                 break;
3059
3060         case LINE_STAT_UNSTAGED:
3061                 text = "Press Enter to stage file for commit  ";
3062                 break;
3063
3064         case LINE_STAT_UNTRACKED:
3065                 text = "Press Enter to stage file for addition";
3066                 break;
3067
3068         case LINE_STAT_NONE:
3069                 return;
3070
3071         default:
3072                 die("w00t");
3073         }
3074
3075         string_ncopy(view->ref, text, strlen(text));
3076 }
3077
3078 static bool
3079 status_grep(struct view *view, struct line *line)
3080 {
3081         struct status *status = line->data;
3082         enum { S_STATUS, S_NAME, S_END } state;
3083         char buf[2] = "?";
3084         regmatch_t pmatch;
3085
3086         if (!status)
3087                 return FALSE;
3088
3089         for (state = S_STATUS; state < S_END; state++) {
3090                 char *text;
3091
3092                 switch (state) {
3093                 case S_NAME:    text = status->name;    break;
3094                 case S_STATUS:
3095                         buf[0] = status->status;
3096                         text = buf;
3097                         break;
3098
3099                 default:
3100                         return FALSE;
3101                 }
3102
3103                 if (regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
3104                         return TRUE;
3105         }
3106
3107         return FALSE;
3108 }
3109
3110 static struct view_ops status_ops = {
3111         "file",
3112         status_open,
3113         NULL,
3114         status_draw,
3115         status_enter,
3116         status_grep,
3117         status_select,
3118 };
3119
3120
3121 /*
3122  * Revision graph
3123  */
3124
3125 struct commit {
3126         char id[SIZEOF_REV];            /* SHA1 ID. */
3127         char title[128];                /* First line of the commit message. */
3128         char author[75];                /* Author of the commit. */
3129         struct tm time;                 /* Date from the author ident. */
3130         struct ref **refs;              /* Repository references. */
3131         chtype graph[SIZEOF_REVGRAPH];  /* Ancestry chain graphics. */
3132         size_t graph_size;              /* The width of the graph array. */
3133 };
3134
3135 /* Size of rev graph with no  "padding" columns */
3136 #define SIZEOF_REVITEMS (SIZEOF_REVGRAPH - (SIZEOF_REVGRAPH / 2))
3137
3138 struct rev_graph {
3139         struct rev_graph *prev, *next, *parents;
3140         char rev[SIZEOF_REVITEMS][SIZEOF_REV];
3141         size_t size;
3142         struct commit *commit;
3143         size_t pos;
3144 };
3145
3146 /* Parents of the commit being visualized. */
3147 static struct rev_graph graph_parents[4];
3148
3149 /* The current stack of revisions on the graph. */
3150 static struct rev_graph graph_stacks[4] = {
3151         { &graph_stacks[3], &graph_stacks[1], &graph_parents[0] },
3152         { &graph_stacks[0], &graph_stacks[2], &graph_parents[1] },
3153         { &graph_stacks[1], &graph_stacks[3], &graph_parents[2] },
3154         { &graph_stacks[2], &graph_stacks[0], &graph_parents[3] },
3155 };
3156
3157 static inline bool
3158 graph_parent_is_merge(struct rev_graph *graph)
3159 {
3160         return graph->parents->size > 1;
3161 }
3162
3163 static inline void
3164 append_to_rev_graph(struct rev_graph *graph, chtype symbol)
3165 {
3166         struct commit *commit = graph->commit;
3167
3168         if (commit->graph_size < ARRAY_SIZE(commit->graph) - 1)
3169                 commit->graph[commit->graph_size++] = symbol;
3170 }
3171
3172 static void
3173 done_rev_graph(struct rev_graph *graph)
3174 {
3175         if (graph_parent_is_merge(graph) &&
3176             graph->pos < graph->size - 1 &&
3177             graph->next->size == graph->size + graph->parents->size - 1) {
3178                 size_t i = graph->pos + graph->parents->size - 1;
3179
3180                 graph->commit->graph_size = i * 2;
3181                 while (i < graph->next->size - 1) {
3182                         append_to_rev_graph(graph, ' ');
3183                         append_to_rev_graph(graph, '\\');
3184                         i++;
3185                 }
3186         }
3187
3188         graph->size = graph->pos = 0;
3189         graph->commit = NULL;
3190         memset(graph->parents, 0, sizeof(*graph->parents));
3191 }
3192
3193 static void
3194 push_rev_graph(struct rev_graph *graph, char *parent)
3195 {
3196         int i;
3197
3198         /* "Collapse" duplicate parents lines.
3199          *
3200          * FIXME: This needs to also update update the drawn graph but
3201          * for now it just serves as a method for pruning graph lines. */
3202         for (i = 0; i < graph->size; i++)
3203                 if (!strncmp(graph->rev[i], parent, SIZEOF_REV))
3204                         return;
3205
3206         if (graph->size < SIZEOF_REVITEMS) {
3207                 string_copy_rev(graph->rev[graph->size++], parent);
3208         }
3209 }
3210
3211 static chtype
3212 get_rev_graph_symbol(struct rev_graph *graph)
3213 {
3214         chtype symbol;
3215
3216         if (graph->parents->size == 0)
3217                 symbol = REVGRAPH_INIT;
3218         else if (graph_parent_is_merge(graph))
3219                 symbol = REVGRAPH_MERGE;
3220         else if (graph->pos >= graph->size)
3221                 symbol = REVGRAPH_BRANCH;
3222         else
3223                 symbol = REVGRAPH_COMMIT;
3224
3225         return symbol;
3226 }
3227
3228 static void
3229 draw_rev_graph(struct rev_graph *graph)
3230 {
3231         struct rev_filler {
3232                 chtype separator, line;
3233         };
3234         enum { DEFAULT, RSHARP, RDIAG, LDIAG };
3235         static struct rev_filler fillers[] = {
3236                 { ' ',  REVGRAPH_LINE },
3237                 { '`',  '.' },
3238                 { '\'', ' ' },
3239                 { '/',  ' ' },
3240         };
3241         chtype symbol = get_rev_graph_symbol(graph);
3242         struct rev_filler *filler;
3243         size_t i;
3244
3245         filler = &fillers[DEFAULT];
3246
3247         for (i = 0; i < graph->pos; i++) {
3248                 append_to_rev_graph(graph, filler->line);
3249                 if (graph_parent_is_merge(graph->prev) &&
3250                     graph->prev->pos == i)
3251                         filler = &fillers[RSHARP];
3252
3253                 append_to_rev_graph(graph, filler->separator);
3254         }
3255
3256         /* Place the symbol for this revision. */
3257         append_to_rev_graph(graph, symbol);
3258
3259         if (graph->prev->size > graph->size)
3260                 filler = &fillers[RDIAG];
3261         else
3262                 filler = &fillers[DEFAULT];
3263
3264         i++;
3265
3266         for (; i < graph->size; i++) {
3267                 append_to_rev_graph(graph, filler->separator);
3268                 append_to_rev_graph(graph, filler->line);
3269                 if (graph_parent_is_merge(graph->prev) &&
3270                     i < graph->prev->pos + graph->parents->size)
3271                         filler = &fillers[RSHARP];
3272                 if (graph->prev->size > graph->size)
3273                         filler = &fillers[LDIAG];
3274         }
3275
3276         if (graph->prev->size > graph->size) {
3277                 append_to_rev_graph(graph, filler->separator);
3278                 if (filler->line != ' ')
3279                         append_to_rev_graph(graph, filler->line);
3280         }
3281 }
3282
3283 /* Prepare the next rev graph */
3284 static void
3285 prepare_rev_graph(struct rev_graph *graph)
3286 {
3287         size_t i;
3288
3289         /* First, traverse all lines of revisions up to the active one. */
3290         for (graph->pos = 0; graph->pos < graph->size; graph->pos++) {
3291                 if (!strcmp(graph->rev[graph->pos], graph->commit->id))
3292                         break;
3293
3294                 push_rev_graph(graph->next, graph->rev[graph->pos]);
3295         }
3296
3297         /* Interleave the new revision parent(s). */
3298         for (i = 0; i < graph->parents->size; i++)
3299                 push_rev_graph(graph->next, graph->parents->rev[i]);
3300
3301         /* Lastly, put any remaining revisions. */
3302         for (i = graph->pos + 1; i < graph->size; i++)
3303                 push_rev_graph(graph->next, graph->rev[i]);
3304 }
3305
3306 static void
3307 update_rev_graph(struct rev_graph *graph)
3308 {
3309         /* If this is the finalizing update ... */
3310         if (graph->commit)
3311                 prepare_rev_graph(graph);
3312
3313         /* Graph visualization needs a one rev look-ahead,
3314          * so the first update doesn't visualize anything. */
3315         if (!graph->prev->commit)
3316                 return;
3317
3318         draw_rev_graph(graph->prev);
3319         done_rev_graph(graph->prev->prev);
3320 }
3321
3322
3323 /*
3324  * Main view backend
3325  */
3326
3327 static bool
3328 main_draw(struct view *view, struct line *line, unsigned int lineno, bool selected)
3329 {
3330         char buf[DATE_COLS + 1];
3331         struct commit *commit = line->data;
3332         enum line_type type;
3333         int col = 0;
3334         size_t timelen;
3335         size_t authorlen;
3336         int trimmed = 1;
3337
3338         if (!*commit->author)
3339                 return FALSE;
3340
3341         wmove(view->win, lineno, col);
3342
3343         if (selected) {
3344                 type = LINE_CURSOR;
3345                 wattrset(view->win, get_line_attr(type));
3346                 wchgat(view->win, -1, 0, type, NULL);
3347
3348         } else {
3349                 type = LINE_MAIN_COMMIT;
3350                 wattrset(view->win, get_line_attr(LINE_MAIN_DATE));
3351         }
3352
3353         timelen = strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time);
3354         waddnstr(view->win, buf, timelen);
3355         waddstr(view->win, " ");
3356
3357         col += DATE_COLS;
3358         wmove(view->win, lineno, col);
3359         if (type != LINE_CURSOR)
3360                 wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
3361
3362         if (opt_utf8) {
3363                 authorlen = utf8_length(commit->author, AUTHOR_COLS - 2, &col, &trimmed);
3364         } else {
3365                 authorlen = strlen(commit->author);
3366                 if (authorlen > AUTHOR_COLS - 2) {
3367                         authorlen = AUTHOR_COLS - 2;
3368                         trimmed = 1;
3369                 }
3370         }
3371
3372         if (trimmed) {
3373                 waddnstr(view->win, commit->author, authorlen);
3374                 if (type != LINE_CURSOR)
3375                         wattrset(view->win, get_line_attr(LINE_MAIN_DELIM));
3376                 waddch(view->win, '~');
3377         } else {
3378                 waddstr(view->win, commit->author);
3379         }
3380
3381         col += AUTHOR_COLS;
3382         if (type != LINE_CURSOR)
3383                 wattrset(view->win, A_NORMAL);
3384
3385         if (opt_rev_graph && commit->graph_size) {
3386                 size_t i;
3387
3388                 wmove(view->win, lineno, col);
3389                 /* Using waddch() instead of waddnstr() ensures that
3390                  * they'll be rendered correctly for the cursor line. */
3391                 for (i = 0; i < commit->graph_size; i++)
3392                         waddch(view->win, commit->graph[i]);
3393
3394                 waddch(view->win, ' ');
3395                 col += commit->graph_size + 1;
3396         }
3397
3398         wmove(view->win, lineno, col);
3399
3400         if (commit->refs) {
3401                 size_t i = 0;
3402
3403                 do {
3404                         if (type == LINE_CURSOR)
3405                                 ;
3406                         else if (commit->refs[i]->tag)
3407                                 wattrset(view->win, get_line_attr(LINE_MAIN_TAG));
3408                         else if (commit->refs[i]->remote)
3409                                 wattrset(view->win, get_line_attr(LINE_MAIN_REMOTE));
3410                         else
3411                                 wattrset(view->win, get_line_attr(LINE_MAIN_REF));
3412                         waddstr(view->win, "[");
3413                         waddstr(view->win, commit->refs[i]->name);
3414                         waddstr(view->win, "]");
3415                         if (type != LINE_CURSOR)
3416                                 wattrset(view->win, A_NORMAL);
3417                         waddstr(view->win, " ");
3418                         col += strlen(commit->refs[i]->name) + STRING_SIZE("[] ");
3419                 } while (commit->refs[i++]->next);
3420         }
3421
3422         if (type != LINE_CURSOR)
3423                 wattrset(view->win, get_line_attr(type));
3424
3425         {
3426                 int titlelen = strlen(commit->title);
3427
3428                 if (col + titlelen > view->width)
3429                         titlelen = view->width - col;
3430
3431                 waddnstr(view->win, commit->title, titlelen);
3432         }
3433
3434         return TRUE;
3435 }
3436
3437 /* Reads git log --pretty=raw output and parses it into the commit struct. */
3438 static bool
3439 main_read(struct view *view, char *line)
3440 {
3441         static struct rev_graph *graph = graph_stacks;
3442         enum line_type type;
3443         struct commit *commit;
3444
3445         if (!line) {
3446                 update_rev_graph(graph);
3447                 return TRUE;
3448         }
3449
3450         type = get_line_type(line);
3451         if (type == LINE_COMMIT) {
3452                 commit = calloc(1, sizeof(struct commit));
3453                 if (!commit)
3454                         return FALSE;
3455
3456                 string_copy_rev(commit->id, line + STRING_SIZE("commit "));
3457                 commit->refs = get_refs(commit->id);
3458                 graph->commit = commit;
3459                 add_line_data(view, commit, LINE_MAIN_COMMIT);
3460                 return TRUE;
3461         }
3462
3463         if (!view->lines)
3464                 return TRUE;
3465         commit = view->line[view->lines - 1].data;
3466
3467         switch (type) {
3468         case LINE_PARENT:
3469                 push_rev_graph(graph->parents, line + STRING_SIZE("parent "));
3470                 break;
3471
3472         case LINE_AUTHOR:
3473         {
3474                 /* Parse author lines where the name may be empty:
3475                  *      author  <email@address.tld> 1138474660 +0100
3476                  */
3477                 char *ident = line + STRING_SIZE("author ");
3478                 char *nameend = strchr(ident, '<');
3479                 char *emailend = strchr(ident, '>');
3480
3481                 if (!nameend || !emailend)
3482                         break;
3483
3484                 update_rev_graph(graph);
3485                 graph = graph->next;
3486
3487                 *nameend = *emailend = 0;
3488                 ident = chomp_string(ident);
3489                 if (!*ident) {
3490                         ident = chomp_string(nameend + 1);
3491                         if (!*ident)
3492                                 ident = "Unknown";
3493                 }
3494
3495                 string_ncopy(commit->author, ident, strlen(ident));
3496
3497                 /* Parse epoch and timezone */
3498                 if (emailend[1] == ' ') {
3499                         char *secs = emailend + 2;
3500                         char *zone = strchr(secs, ' ');
3501                         time_t time = (time_t) atol(secs);
3502
3503                         if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
3504                                 long tz;
3505
3506                                 zone++;
3507                                 tz  = ('0' - zone[1]) * 60 * 60 * 10;
3508                                 tz += ('0' - zone[2]) * 60 * 60;
3509                                 tz += ('0' - zone[3]) * 60;
3510                                 tz += ('0' - zone[4]) * 60;
3511
3512                                 if (zone[0] == '-')
3513                                         tz = -tz;
3514
3515                                 time -= tz;
3516                         }
3517
3518                         gmtime_r(&time, &commit->time);
3519                 }
3520                 break;
3521         }
3522         default:
3523                 /* Fill in the commit title if it has not already been set. */
3524                 if (commit->title[0])
3525                         break;
3526
3527                 /* Require titles to start with a non-space character at the
3528                  * offset used by git log. */
3529                 if (strncmp(line, "    ", 4))
3530                         break;
3531                 line += 4;
3532                 /* Well, if the title starts with a whitespace character,
3533                  * try to be forgiving.  Otherwise we end up with no title. */
3534                 while (isspace(*line))
3535                         line++;
3536                 if (*line == '\0')
3537                         break;
3538                 /* FIXME: More graceful handling of titles; append "..." to
3539                  * shortened titles, etc. */
3540
3541                 string_ncopy(commit->title, line, strlen(line));
3542         }
3543
3544         return TRUE;
3545 }
3546
3547 static bool
3548 main_enter(struct view *view, struct line *line)
3549 {
3550         enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
3551
3552         open_view(view, REQ_VIEW_DIFF, flags);
3553         return TRUE;
3554 }
3555
3556 static bool
3557 main_grep(struct view *view, struct line *line)
3558 {
3559         struct commit *commit = line->data;
3560         enum { S_TITLE, S_AUTHOR, S_DATE, S_END } state;
3561         char buf[DATE_COLS + 1];
3562         regmatch_t pmatch;
3563
3564         for (state = S_TITLE; state < S_END; state++) {
3565                 char *text;
3566
3567                 switch (state) {
3568                 case S_TITLE:   text = commit->title;   break;
3569                 case S_AUTHOR:  text = commit->author;  break;
3570                 case S_DATE:
3571                         if (!strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time))
3572                                 continue;
3573                         text = buf;
3574                         break;
3575
3576                 default:
3577                         return FALSE;
3578                 }
3579
3580                 if (regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
3581                         return TRUE;
3582         }
3583
3584         return FALSE;
3585 }
3586
3587 static void
3588 main_select(struct view *view, struct line *line)
3589 {
3590         struct commit *commit = line->data;
3591
3592         string_copy_rev(view->ref, commit->id);
3593         string_copy_rev(ref_commit, view->ref);
3594 }
3595
3596 static struct view_ops main_ops = {
3597         "commit",
3598         NULL,
3599         main_read,
3600         main_draw,
3601         main_enter,
3602         main_grep,
3603         main_select,
3604 };
3605
3606
3607 /*
3608  * Unicode / UTF-8 handling
3609  *
3610  * NOTE: Much of the following code for dealing with unicode is derived from
3611  * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
3612  * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
3613  */
3614
3615 /* I've (over)annotated a lot of code snippets because I am not entirely
3616  * confident that the approach taken by this small UTF-8 interface is correct.
3617  * --jonas */
3618
3619 static inline int
3620 unicode_width(unsigned long c)
3621 {
3622         if (c >= 0x1100 &&
3623            (c <= 0x115f                         /* Hangul Jamo */
3624             || c == 0x2329
3625             || c == 0x232a
3626             || (c >= 0x2e80  && c <= 0xa4cf && c != 0x303f)
3627                                                 /* CJK ... Yi */
3628             || (c >= 0xac00  && c <= 0xd7a3)    /* Hangul Syllables */
3629             || (c >= 0xf900  && c <= 0xfaff)    /* CJK Compatibility Ideographs */
3630             || (c >= 0xfe30  && c <= 0xfe6f)    /* CJK Compatibility Forms */
3631             || (c >= 0xff00  && c <= 0xff60)    /* Fullwidth Forms */
3632             || (c >= 0xffe0  && c <= 0xffe6)
3633             || (c >= 0x20000 && c <= 0x2fffd)
3634             || (c >= 0x30000 && c <= 0x3fffd)))
3635                 return 2;
3636
3637         return 1;
3638 }
3639
3640 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
3641  * Illegal bytes are set one. */
3642 static const unsigned char utf8_bytes[256] = {
3643         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,
3644         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,
3645         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,
3646         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,
3647         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,
3648         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,
3649         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,
3650         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,
3651 };
3652
3653 /* Decode UTF-8 multi-byte representation into a unicode character. */
3654 static inline unsigned long
3655 utf8_to_unicode(const char *string, size_t length)
3656 {
3657         unsigned long unicode;
3658
3659         switch (length) {
3660         case 1:
3661                 unicode  =   string[0];
3662                 break;
3663         case 2:
3664                 unicode  =  (string[0] & 0x1f) << 6;
3665                 unicode +=  (string[1] & 0x3f);
3666                 break;
3667         case 3:
3668                 unicode  =  (string[0] & 0x0f) << 12;
3669                 unicode += ((string[1] & 0x3f) << 6);
3670                 unicode +=  (string[2] & 0x3f);
3671                 break;
3672         case 4:
3673                 unicode  =  (string[0] & 0x0f) << 18;
3674                 unicode += ((string[1] & 0x3f) << 12);
3675                 unicode += ((string[2] & 0x3f) << 6);
3676                 unicode +=  (string[3] & 0x3f);
3677                 break;
3678         case 5:
3679                 unicode  =  (string[0] & 0x0f) << 24;
3680                 unicode += ((string[1] & 0x3f) << 18);
3681                 unicode += ((string[2] & 0x3f) << 12);
3682                 unicode += ((string[3] & 0x3f) << 6);
3683                 unicode +=  (string[4] & 0x3f);
3684                 break;
3685         case 6:
3686                 unicode  =  (string[0] & 0x01) << 30;
3687                 unicode += ((string[1] & 0x3f) << 24);
3688                 unicode += ((string[2] & 0x3f) << 18);
3689                 unicode += ((string[3] & 0x3f) << 12);
3690                 unicode += ((string[4] & 0x3f) << 6);
3691                 unicode +=  (string[5] & 0x3f);
3692                 break;
3693         default:
3694                 die("Invalid unicode length");
3695         }
3696
3697         /* Invalid characters could return the special 0xfffd value but NUL
3698          * should be just as good. */
3699         return unicode > 0xffff ? 0 : unicode;
3700 }
3701
3702 /* Calculates how much of string can be shown within the given maximum width
3703  * and sets trimmed parameter to non-zero value if all of string could not be
3704  * shown.
3705  *
3706  * Additionally, adds to coloffset how many many columns to move to align with
3707  * the expected position. Takes into account how multi-byte and double-width
3708  * characters will effect the cursor position.
3709  *
3710  * Returns the number of bytes to output from string to satisfy max_width. */
3711 static size_t
3712 utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed)
3713 {
3714         const char *start = string;
3715         const char *end = strchr(string, '\0');
3716         size_t mbwidth = 0;
3717         size_t width = 0;
3718
3719         *trimmed = 0;
3720
3721         while (string < end) {
3722                 int c = *(unsigned char *) string;
3723                 unsigned char bytes = utf8_bytes[c];
3724                 size_t ucwidth;
3725                 unsigned long unicode;
3726
3727                 if (string + bytes > end)
3728                         break;
3729
3730                 /* Change representation to figure out whether
3731                  * it is a single- or double-width character. */
3732
3733                 unicode = utf8_to_unicode(string, bytes);
3734                 /* FIXME: Graceful handling of invalid unicode character. */
3735                 if (!unicode)
3736                         break;
3737
3738                 ucwidth = unicode_width(unicode);
3739                 width  += ucwidth;
3740                 if (width > max_width) {
3741                         *trimmed = 1;
3742                         break;
3743                 }
3744
3745                 /* The column offset collects the differences between the
3746                  * number of bytes encoding a character and the number of
3747                  * columns will be used for rendering said character.
3748                  *
3749                  * So if some character A is encoded in 2 bytes, but will be
3750                  * represented on the screen using only 1 byte this will and up
3751                  * adding 1 to the multi-byte column offset.
3752                  *
3753                  * Assumes that no double-width character can be encoding in
3754                  * less than two bytes. */
3755                 if (bytes > ucwidth)
3756                         mbwidth += bytes - ucwidth;
3757
3758                 string  += bytes;
3759         }
3760
3761         *coloffset += mbwidth;
3762
3763         return string - start;
3764 }
3765
3766
3767 /*
3768  * Status management
3769  */
3770
3771 /* Whether or not the curses interface has been initialized. */
3772 static bool cursed = FALSE;
3773
3774 /* The status window is used for polling keystrokes. */
3775 static WINDOW *status_win;
3776
3777 static bool status_empty = TRUE;
3778
3779 /* Update status and title window. */
3780 static void
3781 report(const char *msg, ...)
3782 {
3783         struct view *view = display[current_view];
3784
3785         if (input_mode)
3786                 return;
3787
3788         if (!status_empty || *msg) {
3789                 va_list args;
3790
3791                 va_start(args, msg);
3792
3793                 wmove(status_win, 0, 0);
3794                 if (*msg) {
3795                         vwprintw(status_win, msg, args);
3796                         status_empty = FALSE;
3797                 } else {
3798                         status_empty = TRUE;
3799                 }
3800                 wclrtoeol(status_win);
3801                 wrefresh(status_win);
3802
3803                 va_end(args);
3804         }
3805
3806         update_view_title(view);
3807         update_display_cursor(view);
3808 }
3809
3810 /* Controls when nodelay should be in effect when polling user input. */
3811 static void
3812 set_nonblocking_input(bool loading)
3813 {
3814         static unsigned int loading_views;
3815
3816         if ((loading == FALSE && loading_views-- == 1) ||
3817             (loading == TRUE  && loading_views++ == 0))
3818                 nodelay(status_win, loading);
3819 }
3820
3821 static void
3822 init_display(void)
3823 {
3824         int x, y;
3825
3826         /* Initialize the curses library */
3827         if (isatty(STDIN_FILENO)) {
3828                 cursed = !!initscr();
3829         } else {
3830                 /* Leave stdin and stdout alone when acting as a pager. */
3831                 FILE *io = fopen("/dev/tty", "r+");
3832
3833                 if (!io)
3834                         die("Failed to open /dev/tty");
3835                 cursed = !!newterm(NULL, io, io);
3836         }
3837
3838         if (!cursed)
3839                 die("Failed to initialize curses");
3840
3841         nonl();         /* Tell curses not to do NL->CR/NL on output */
3842         cbreak();       /* Take input chars one at a time, no wait for \n */
3843         noecho();       /* Don't echo input */
3844         leaveok(stdscr, TRUE);
3845
3846         if (has_colors())
3847                 init_colors();
3848
3849         getmaxyx(stdscr, y, x);
3850         status_win = newwin(1, 0, y - 1, 0);
3851         if (!status_win)
3852                 die("Failed to create status window");
3853
3854         /* Enable keyboard mapping */
3855         keypad(status_win, TRUE);
3856         wbkgdset(status_win, get_line_attr(LINE_STATUS));
3857 }
3858
3859 static char *
3860 read_prompt(const char *prompt)
3861 {
3862         enum { READING, STOP, CANCEL } status = READING;
3863         static char buf[sizeof(opt_cmd) - STRING_SIZE("git \0")];
3864         int pos = 0;
3865
3866         while (status == READING) {
3867                 struct view *view;
3868                 int i, key;
3869
3870                 input_mode = TRUE;
3871
3872                 foreach_view (view, i)
3873                         update_view(view);
3874
3875                 input_mode = FALSE;
3876
3877                 mvwprintw(status_win, 0, 0, "%s%.*s", prompt, pos, buf);
3878                 wclrtoeol(status_win);
3879
3880                 /* Refresh, accept single keystroke of input */
3881                 key = wgetch(status_win);
3882                 switch (key) {
3883                 case KEY_RETURN:
3884                 case KEY_ENTER:
3885                 case '\n':
3886                         status = pos ? STOP : CANCEL;
3887                         break;
3888
3889                 case KEY_BACKSPACE:
3890                         if (pos > 0)
3891                                 pos--;
3892                         else
3893                                 status = CANCEL;
3894                         break;
3895
3896                 case KEY_ESC:
3897                         status = CANCEL;
3898                         break;
3899
3900                 case ERR:
3901                         break;
3902
3903                 default:
3904                         if (pos >= sizeof(buf)) {
3905                                 report("Input string too long");
3906                                 return NULL;
3907                         }
3908
3909                         if (isprint(key))
3910                                 buf[pos++] = (char) key;
3911                 }
3912         }
3913
3914         /* Clear the status window */
3915         status_empty = FALSE;
3916         report("");
3917
3918         if (status == CANCEL)
3919                 return NULL;
3920
3921         buf[pos++] = 0;
3922
3923         return buf;
3924 }
3925
3926 /*
3927  * Repository references
3928  */
3929
3930 static struct ref *refs;
3931 static size_t refs_size;
3932
3933 /* Id <-> ref store */
3934 static struct ref ***id_refs;
3935 static size_t id_refs_size;
3936
3937 static struct ref **
3938 get_refs(char *id)
3939 {
3940         struct ref ***tmp_id_refs;
3941         struct ref **ref_list = NULL;
3942         size_t ref_list_size = 0;
3943         size_t i;
3944
3945         for (i = 0; i < id_refs_size; i++)
3946                 if (!strcmp(id, id_refs[i][0]->id))
3947                         return id_refs[i];
3948
3949         tmp_id_refs = realloc(id_refs, (id_refs_size + 1) * sizeof(*id_refs));
3950         if (!tmp_id_refs)
3951                 return NULL;
3952
3953         id_refs = tmp_id_refs;
3954
3955         for (i = 0; i < refs_size; i++) {
3956                 struct ref **tmp;
3957
3958                 if (strcmp(id, refs[i].id))
3959                         continue;
3960
3961                 tmp = realloc(ref_list, (ref_list_size + 1) * sizeof(*ref_list));
3962                 if (!tmp) {
3963                         if (ref_list)
3964                                 free(ref_list);
3965                         return NULL;
3966                 }
3967
3968                 ref_list = tmp;
3969                 if (ref_list_size > 0)
3970                         ref_list[ref_list_size - 1]->next = 1;
3971                 ref_list[ref_list_size] = &refs[i];
3972
3973                 /* XXX: The properties of the commit chains ensures that we can
3974                  * safely modify the shared ref. The repo references will
3975                  * always be similar for the same id. */
3976                 ref_list[ref_list_size]->next = 0;
3977                 ref_list_size++;
3978         }
3979
3980         if (ref_list)
3981                 id_refs[id_refs_size++] = ref_list;
3982
3983         return ref_list;
3984 }
3985
3986 static int
3987 read_ref(char *id, size_t idlen, char *name, size_t namelen)
3988 {
3989         struct ref *ref;
3990         bool tag = FALSE;
3991         bool remote = FALSE;
3992
3993         if (!strncmp(name, "refs/tags/", STRING_SIZE("refs/tags/"))) {
3994                 /* Commits referenced by tags has "^{}" appended. */
3995                 if (name[namelen - 1] != '}')
3996                         return OK;
3997
3998                 while (namelen > 0 && name[namelen] != '^')
3999                         namelen--;
4000
4001                 tag = TRUE;
4002                 namelen -= STRING_SIZE("refs/tags/");
4003                 name    += STRING_SIZE("refs/tags/");
4004
4005         } else if (!strncmp(name, "refs/remotes/", STRING_SIZE("refs/remotes/"))) {
4006                 remote = TRUE;
4007                 namelen -= STRING_SIZE("refs/remotes/");
4008                 name    += STRING_SIZE("refs/remotes/");
4009
4010         } else if (!strncmp(name, "refs/heads/", STRING_SIZE("refs/heads/"))) {
4011                 namelen -= STRING_SIZE("refs/heads/");
4012                 name    += STRING_SIZE("refs/heads/");
4013
4014         } else if (!strcmp(name, "HEAD")) {
4015                 return OK;
4016         }
4017
4018         refs = realloc(refs, sizeof(*refs) * (refs_size + 1));
4019         if (!refs)
4020                 return ERR;
4021
4022         ref = &refs[refs_size++];
4023         ref->name = malloc(namelen + 1);
4024         if (!ref->name)
4025                 return ERR;
4026
4027         strncpy(ref->name, name, namelen);
4028         ref->name[namelen] = 0;
4029         ref->tag = tag;
4030         ref->remote = remote;
4031         string_copy_rev(ref->id, id);
4032
4033         return OK;
4034 }
4035
4036 static int
4037 load_refs(void)
4038 {
4039         const char *cmd_env = getenv("TIG_LS_REMOTE");
4040         const char *cmd = cmd_env && *cmd_env ? cmd_env : TIG_LS_REMOTE;
4041
4042         return read_properties(popen(cmd, "r"), "\t", read_ref);
4043 }
4044
4045 static int
4046 read_repo_config_option(char *name, size_t namelen, char *value, size_t valuelen)
4047 {
4048         if (!strcmp(name, "i18n.commitencoding"))
4049                 string_ncopy(opt_encoding, value, valuelen);
4050
4051         return OK;
4052 }
4053
4054 static int
4055 load_repo_config(void)
4056 {
4057         return read_properties(popen("git repo-config --list", "r"),
4058                                "=", read_repo_config_option);
4059 }
4060
4061 static int
4062 read_repo_info(char *name, size_t namelen, char *value, size_t valuelen)
4063 {
4064         if (!opt_cdup[0])
4065                 string_ncopy(opt_cdup, name, namelen);
4066         return OK;
4067 }
4068
4069 static int
4070 load_repo_info(void)
4071 {
4072         return read_properties(popen("git rev-parse --show-cdup", "r"),
4073                                "=", read_repo_info);
4074 }
4075
4076 static int
4077 read_properties(FILE *pipe, const char *separators,
4078                 int (*read_property)(char *, size_t, char *, size_t))
4079 {
4080         char buffer[BUFSIZ];
4081         char *name;
4082         int state = OK;
4083
4084         if (!pipe)
4085                 return ERR;
4086
4087         while (state == OK && (name = fgets(buffer, sizeof(buffer), pipe))) {
4088                 char *value;
4089                 size_t namelen;
4090                 size_t valuelen;
4091
4092                 name = chomp_string(name);
4093                 namelen = strcspn(name, separators);
4094
4095                 if (name[namelen]) {
4096                         name[namelen] = 0;
4097                         value = chomp_string(name + namelen + 1);
4098                         valuelen = strlen(value);
4099
4100                 } else {
4101                         value = "";
4102                         valuelen = 0;
4103                 }
4104
4105                 state = read_property(name, namelen, value, valuelen);
4106         }
4107
4108         if (state != ERR && ferror(pipe))
4109                 state = ERR;
4110
4111         pclose(pipe);
4112
4113         return state;
4114 }
4115
4116
4117 /*
4118  * Main
4119  */
4120
4121 static void __NORETURN
4122 quit(int sig)
4123 {
4124         /* XXX: Restore tty modes and let the OS cleanup the rest! */
4125         if (cursed)
4126                 endwin();
4127         exit(0);
4128 }
4129
4130 static void __NORETURN
4131 die(const char *err, ...)
4132 {
4133         va_list args;
4134
4135         endwin();
4136
4137         va_start(args, err);
4138         fputs("tig: ", stderr);
4139         vfprintf(stderr, err, args);
4140         fputs("\n", stderr);
4141         va_end(args);
4142
4143         exit(1);
4144 }
4145
4146 int
4147 main(int argc, char *argv[])
4148 {
4149         struct view *view;
4150         enum request request;
4151         size_t i;
4152
4153         signal(SIGINT, quit);
4154
4155         if (setlocale(LC_ALL, "")) {
4156                 char *codeset = nl_langinfo(CODESET);
4157
4158                 string_ncopy(opt_codeset, codeset, strlen(codeset));
4159         }
4160
4161         if (load_options() == ERR)
4162                 die("Failed to load user config.");
4163
4164         /* Load the repo config file so options can be overwritten from
4165          * the command line. */
4166         if (load_repo_config() == ERR)
4167                 die("Failed to load repo config.");
4168
4169         if (load_repo_info() == ERR)
4170                 die("Failed to load repo info.");
4171
4172         if (!parse_options(argc, argv))
4173                 return 0;
4174
4175         if (*opt_codeset && strcmp(opt_codeset, opt_encoding)) {
4176                 opt_iconv = iconv_open(opt_codeset, opt_encoding);
4177                 if (opt_iconv == ICONV_NONE)
4178                         die("Failed to initialize character set conversion");
4179         }
4180
4181         if (load_refs() == ERR)
4182                 die("Failed to load refs.");
4183
4184         /* Require a git repository unless when running in pager mode. */
4185         if (refs_size == 0 && opt_request != REQ_VIEW_PAGER)
4186                 die("Not a git repository");
4187
4188         for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
4189                 view->cmd_env = getenv(view->cmd_env);
4190
4191         request = opt_request;
4192
4193         init_display();
4194
4195         while (view_driver(display[current_view], request)) {
4196                 int key;
4197                 int i;
4198
4199                 foreach_view (view, i)
4200                         update_view(view);
4201
4202                 /* Refresh, accept single keystroke of input */
4203                 key = wgetch(status_win);
4204
4205                 /* wgetch() with nodelay() enabled returns ERR when there's no
4206                  * input. */
4207                 if (key == ERR) {
4208                         request = REQ_NONE;
4209                         continue;
4210                 }
4211
4212                 request = get_keybinding(display[current_view]->keymap, key);
4213
4214                 /* Some low-level request handling. This keeps access to
4215                  * status_win restricted. */
4216                 switch (request) {
4217                 case REQ_PROMPT:
4218                 {
4219                         char *cmd = read_prompt(":");
4220
4221                         if (cmd && string_format(opt_cmd, "git %s", cmd)) {
4222                                 if (strncmp(cmd, "show", 4) && isspace(cmd[4])) {
4223                                         opt_request = REQ_VIEW_DIFF;
4224                                 } else {
4225                                         opt_request = REQ_VIEW_PAGER;
4226                                 }
4227                                 break;
4228                         }
4229
4230                         request = REQ_NONE;
4231                         break;
4232                 }
4233                 case REQ_SEARCH:
4234                 case REQ_SEARCH_BACK:
4235                 {
4236                         const char *prompt = request == REQ_SEARCH
4237                                            ? "/" : "?";
4238                         char *search = read_prompt(prompt);
4239
4240                         if (search)
4241                                 string_ncopy(opt_search, search, strlen(search));
4242                         else
4243                                 request = REQ_NONE;
4244                         break;
4245                 }
4246                 case REQ_SCREEN_RESIZE:
4247                 {
4248                         int height, width;
4249
4250                         getmaxyx(stdscr, height, width);
4251
4252                         /* Resize the status view and let the view driver take
4253                          * care of resizing the displayed views. */
4254                         wresize(status_win, 1, width);
4255                         mvwin(status_win, height - 1, 0);
4256                         wrefresh(status_win);
4257                         break;
4258                 }
4259                 default:
4260                         break;
4261                 }
4262         }
4263
4264         quit(0);
4265
4266         return 0;
4267 }