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

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