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

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