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

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