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