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

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