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