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