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         chtype symbol;
2816         size_t stackpos = 0;
2817         size_t i;
2818
2819         // FIXME: Initial commit ... assert(rev_graph_commit == commit);
2820         fprintf(stderr, "\n%p <%s> ", graph, commit->id);
2821
2822         /* First traverse all lines of revisions up to the active one. */
2823         for (stackpos = 0; stackpos < stack->size; stackpos++) {
2824                 if (!strcmp(stack->rev[stackpos], commit->id)) {
2825                         while (stackpos + 1 < stack->size &&
2826                                !strcmp(stack->rev[stackpos + 1], commit->id))
2827                                 stackpos++;
2828                         break;
2829                 }
2830
2831                 push_rev_stack(graph, stack->rev[stackpos]);
2832                 commit->graph[commit->graph_size++] = ACS_VLINE;
2833                 commit->graph[commit->graph_size++] = ' ';
2834         }
2835
2836         assert(commit->graph_size < ARRAY_SIZE(commit->graph));
2837
2838         for (i = 0; i < graph_parents.size; i++)
2839                 push_rev_stack(graph, graph_parents.rev[i]);
2840
2841         /* Place the symbol for this commit. */
2842         if (graph_parents.size == 0)
2843                 symbol = 'I';
2844         else if (graph_parents.size > 1)
2845                 symbol = 'M';
2846         else if (stackpos >= stack->size)
2847                 symbol = '+';
2848         else
2849                 symbol = '*';
2850
2851         commit->graph[commit->graph_size++] = symbol;
2852
2853         stackpos++;
2854
2855         /* FIXME: Moving branches left and right when collapsing a branch. */
2856         while (stackpos < stack->size) {
2857                 push_rev_stack(graph, stack->rev[stackpos++]);
2858                 commit->graph[commit->graph_size++] = ' ';
2859                 commit->graph[commit->graph_size++] = ACS_VLINE;
2860         }
2861
2862         stack->size = graph_parents.size = 0;
2863 }
2864
2865 /* Reads git log --pretty=raw output and parses it into the commit struct. */
2866 static bool
2867 main_read(struct view *view, char *line)
2868 {
2869         enum line_type type = get_line_type(line);
2870         struct commit *commit = view->lines
2871                               ? view->line[view->lines - 1].data : NULL;
2872
2873         switch (type) {
2874         case LINE_COMMIT:
2875                 commit = calloc(1, sizeof(struct commit));
2876                 if (!commit)
2877                         return FALSE;
2878
2879                 line += STRING_SIZE("commit ");
2880
2881                 view->line[view->lines++].data = commit;
2882                 string_copy(commit->id, line);
2883                 commit->refs = get_refs(commit->id);
2884                 fprintf(stderr, "\n%p [%s]", &graph_stacks[graph_stack_no], commit->id);
2885                 break;
2886
2887         case LINE_PARENT:
2888                 if (commit) {
2889                         line += STRING_SIZE("parent ");
2890                         push_rev_stack(&graph_parents, line);
2891                 }
2892                 break;
2893
2894         case LINE_AUTHOR:
2895         {
2896                 char *ident = line + STRING_SIZE("author ");
2897                 char *end = strchr(ident, '<');
2898
2899                 if (!commit)
2900                         break;
2901
2902                 update_rev_graph(commit);
2903
2904                 if (end) {
2905                         char *email = end + 1;
2906
2907                         for (; end > ident && isspace(end[-1]); end--) ;
2908
2909                         if (end == ident && *email) {
2910                                 ident = email;
2911                                 end = strchr(ident, '>');
2912                                 for (; end > ident && isspace(end[-1]); end--) ;
2913                         }
2914                         *end = 0;
2915                 }
2916
2917                 /* End is NULL or ident meaning there's no author. */
2918                 if (end <= ident)
2919                         ident = "Unknown";
2920
2921                 string_copy(commit->author, ident);
2922
2923                 /* Parse epoch and timezone */
2924                 if (end) {
2925                         char *secs = strchr(end + 1, '>');
2926                         char *zone;
2927                         time_t time;
2928
2929                         if (!secs || secs[1] != ' ')
2930                                 break;
2931
2932                         secs += 2;
2933                         time = (time_t) atol(secs);
2934                         zone = strchr(secs, ' ');
2935                         if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
2936                                 long tz;
2937
2938                                 zone++;
2939                                 tz  = ('0' - zone[1]) * 60 * 60 * 10;
2940                                 tz += ('0' - zone[2]) * 60 * 60;
2941                                 tz += ('0' - zone[3]) * 60;
2942                                 tz += ('0' - zone[4]) * 60;
2943
2944                                 if (zone[0] == '-')
2945                                         tz = -tz;
2946
2947                                 time -= tz;
2948                         }
2949                         gmtime_r(&time, &commit->time);
2950                 }
2951                 break;
2952         }
2953         default:
2954                 if (!commit)
2955                         break;
2956
2957                 /* Fill in the commit title if it has not already been set. */
2958                 if (commit->title[0])
2959                         break;
2960
2961                 /* Require titles to start with a non-space character at the
2962                  * offset used by git log. */
2963                 /* FIXME: More gracefull handling of titles; append "..." to
2964                  * shortened titles, etc. */
2965                 if (strncmp(line, "    ", 4) ||
2966                     isspace(line[4]))
2967                         break;
2968
2969                 string_copy(commit->title, line + 4);
2970         }
2971
2972         return TRUE;
2973 }
2974
2975 static bool
2976 main_enter(struct view *view, struct line *line)
2977 {
2978         enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
2979
2980         open_view(view, REQ_VIEW_DIFF, flags);
2981         return TRUE;
2982 }
2983
2984 static bool
2985 main_grep(struct view *view, struct line *line)
2986 {
2987         struct commit *commit = line->data;
2988         enum { S_TITLE, S_AUTHOR, S_DATE, S_END } state;
2989         char buf[DATE_COLS + 1];
2990         regmatch_t pmatch;
2991
2992         for (state = S_TITLE; state < S_END; state++) {
2993                 char *text;
2994
2995                 switch (state) {
2996                 case S_TITLE:   text = commit->title;   break;
2997                 case S_AUTHOR:  text = commit->author;  break;
2998                 case S_DATE:
2999                         if (!strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time))
3000                                 continue;
3001                         text = buf;
3002                         break;
3003
3004                 default:
3005                         return FALSE;
3006                 }
3007
3008                 if (regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
3009                         return TRUE;
3010         }
3011
3012         return FALSE;
3013 }
3014
3015 static void
3016 main_select(struct view *view, struct line *line)
3017 {
3018         struct commit *commit = line->data;
3019
3020         string_copy(view->ref, commit->id);
3021         string_copy(ref_commit, view->ref);
3022 }
3023
3024 static struct view_ops main_ops = {
3025         "commit",
3026         main_draw,
3027         main_read,
3028         main_enter,
3029         main_grep,
3030         main_select,
3031 };
3032
3033
3034 /*
3035  * Unicode / UTF-8 handling
3036  *
3037  * NOTE: Much of the following code for dealing with unicode is derived from
3038  * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
3039  * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
3040  */
3041
3042 /* I've (over)annotated a lot of code snippets because I am not entirely
3043  * confident that the approach taken by this small UTF-8 interface is correct.
3044  * --jonas */
3045
3046 static inline int
3047 unicode_width(unsigned long c)
3048 {
3049         if (c >= 0x1100 &&
3050            (c <= 0x115f                         /* Hangul Jamo */
3051             || c == 0x2329
3052             || c == 0x232a
3053             || (c >= 0x2e80  && c <= 0xa4cf && c != 0x303f)
3054                                                 /* CJK ... Yi */
3055             || (c >= 0xac00  && c <= 0xd7a3)    /* Hangul Syllables */
3056             || (c >= 0xf900  && c <= 0xfaff)    /* CJK Compatibility Ideographs */
3057             || (c >= 0xfe30  && c <= 0xfe6f)    /* CJK Compatibility Forms */
3058             || (c >= 0xff00  && c <= 0xff60)    /* Fullwidth Forms */
3059             || (c >= 0xffe0  && c <= 0xffe6)
3060             || (c >= 0x20000 && c <= 0x2fffd)
3061             || (c >= 0x30000 && c <= 0x3fffd)))
3062                 return 2;
3063
3064         return 1;
3065 }
3066
3067 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
3068  * Illegal bytes are set one. */
3069 static const unsigned char utf8_bytes[256] = {
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         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,
3074         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,
3075         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,
3076         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,
3077         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,
3078 };
3079
3080 /* Decode UTF-8 multi-byte representation into a unicode character. */
3081 static inline unsigned long
3082 utf8_to_unicode(const char *string, size_t length)
3083 {
3084         unsigned long unicode;
3085
3086         switch (length) {
3087         case 1:
3088                 unicode  =   string[0];
3089                 break;
3090         case 2:
3091                 unicode  =  (string[0] & 0x1f) << 6;
3092                 unicode +=  (string[1] & 0x3f);
3093                 break;
3094         case 3:
3095                 unicode  =  (string[0] & 0x0f) << 12;
3096                 unicode += ((string[1] & 0x3f) << 6);
3097                 unicode +=  (string[2] & 0x3f);
3098                 break;
3099         case 4:
3100                 unicode  =  (string[0] & 0x0f) << 18;
3101                 unicode += ((string[1] & 0x3f) << 12);
3102                 unicode += ((string[2] & 0x3f) << 6);
3103                 unicode +=  (string[3] & 0x3f);
3104                 break;
3105         case 5:
3106                 unicode  =  (string[0] & 0x0f) << 24;
3107                 unicode += ((string[1] & 0x3f) << 18);
3108                 unicode += ((string[2] & 0x3f) << 12);
3109                 unicode += ((string[3] & 0x3f) << 6);
3110                 unicode +=  (string[4] & 0x3f);
3111                 break;
3112         case 6:
3113                 unicode  =  (string[0] & 0x01) << 30;
3114                 unicode += ((string[1] & 0x3f) << 24);
3115                 unicode += ((string[2] & 0x3f) << 18);
3116                 unicode += ((string[3] & 0x3f) << 12);
3117                 unicode += ((string[4] & 0x3f) << 6);
3118                 unicode +=  (string[5] & 0x3f);
3119                 break;
3120         default:
3121                 die("Invalid unicode length");
3122         }
3123
3124         /* Invalid characters could return the special 0xfffd value but NUL
3125          * should be just as good. */
3126         return unicode > 0xffff ? 0 : unicode;
3127 }
3128
3129 /* Calculates how much of string can be shown within the given maximum width
3130  * and sets trimmed parameter to non-zero value if all of string could not be
3131  * shown.
3132  *
3133  * Additionally, adds to coloffset how many many columns to move to align with
3134  * the expected position. Takes into account how multi-byte and double-width
3135  * characters will effect the cursor position.
3136  *
3137  * Returns the number of bytes to output from string to satisfy max_width. */
3138 static size_t
3139 utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed)
3140 {
3141         const char *start = string;
3142         const char *end = strchr(string, '\0');
3143         size_t mbwidth = 0;
3144         size_t width = 0;
3145
3146         *trimmed = 0;
3147
3148         while (string < end) {
3149                 int c = *(unsigned char *) string;
3150                 unsigned char bytes = utf8_bytes[c];
3151                 size_t ucwidth;
3152                 unsigned long unicode;
3153
3154                 if (string + bytes > end)
3155                         break;
3156
3157                 /* Change representation to figure out whether
3158                  * it is a single- or double-width character. */
3159
3160                 unicode = utf8_to_unicode(string, bytes);
3161                 /* FIXME: Graceful handling of invalid unicode character. */
3162                 if (!unicode)
3163                         break;
3164
3165                 ucwidth = unicode_width(unicode);
3166                 width  += ucwidth;
3167                 if (width > max_width) {
3168                         *trimmed = 1;
3169                         break;
3170                 }
3171
3172                 /* The column offset collects the differences between the
3173                  * number of bytes encoding a character and the number of
3174                  * columns will be used for rendering said character.
3175                  *
3176                  * So if some character A is encoded in 2 bytes, but will be
3177                  * represented on the screen using only 1 byte this will and up
3178                  * adding 1 to the multi-byte column offset.
3179                  *
3180                  * Assumes that no double-width character can be encoding in
3181                  * less than two bytes. */
3182                 if (bytes > ucwidth)
3183                         mbwidth += bytes - ucwidth;
3184
3185                 string  += bytes;
3186         }
3187
3188         *coloffset += mbwidth;
3189
3190         return string - start;
3191 }
3192
3193
3194 /*
3195  * Status management
3196  */
3197
3198 /* Whether or not the curses interface has been initialized. */
3199 static bool cursed = FALSE;
3200
3201 /* The status window is used for polling keystrokes. */
3202 static WINDOW *status_win;
3203
3204 /* Update status and title window. */
3205 static void
3206 report(const char *msg, ...)
3207 {
3208         static bool empty = TRUE;
3209         struct view *view = display[current_view];
3210
3211         if (!empty || *msg) {
3212                 va_list args;
3213
3214                 va_start(args, msg);
3215
3216                 werase(status_win);
3217                 wmove(status_win, 0, 0);
3218                 if (*msg) {
3219                         vwprintw(status_win, msg, args);
3220                         empty = FALSE;
3221                 } else {
3222                         empty = TRUE;
3223                 }
3224                 wrefresh(status_win);
3225
3226                 va_end(args);
3227         }
3228
3229         update_view_title(view);
3230         update_display_cursor();
3231 }
3232
3233 /* Controls when nodelay should be in effect when polling user input. */
3234 static void
3235 set_nonblocking_input(bool loading)
3236 {
3237         static unsigned int loading_views;
3238
3239         if ((loading == FALSE && loading_views-- == 1) ||
3240             (loading == TRUE  && loading_views++ == 0))
3241                 nodelay(status_win, loading);
3242 }
3243
3244 static void
3245 init_display(void)
3246 {
3247         int x, y;
3248
3249         /* Initialize the curses library */
3250         if (isatty(STDIN_FILENO)) {
3251                 cursed = !!initscr();
3252         } else {
3253                 /* Leave stdin and stdout alone when acting as a pager. */
3254                 FILE *io = fopen("/dev/tty", "r+");
3255
3256                 if (!io)
3257                         die("Failed to open /dev/tty");
3258                 cursed = !!newterm(NULL, io, io);
3259         }
3260
3261         if (!cursed)
3262                 die("Failed to initialize curses");
3263
3264         nonl();         /* Tell curses not to do NL->CR/NL on output */
3265         cbreak();       /* Take input chars one at a time, no wait for \n */
3266         noecho();       /* Don't echo input */
3267         leaveok(stdscr, TRUE);
3268
3269         if (has_colors())
3270                 init_colors();
3271
3272         getmaxyx(stdscr, y, x);
3273         status_win = newwin(1, 0, y - 1, 0);
3274         if (!status_win)
3275                 die("Failed to create status window");
3276
3277         /* Enable keyboard mapping */
3278         keypad(status_win, TRUE);
3279         wbkgdset(status_win, get_line_attr(LINE_STATUS));
3280 }
3281
3282 static char *
3283 read_prompt(const char *prompt)
3284 {
3285         enum { READING, STOP, CANCEL } status = READING;
3286         static char buf[sizeof(opt_cmd) - STRING_SIZE("git \0")];
3287         int pos = 0;
3288
3289         while (status == READING) {
3290                 struct view *view;
3291                 int i, key;
3292
3293                 foreach_view (view, i)
3294                         update_view(view);
3295
3296                 report("%s%.*s", prompt, pos, buf);
3297                 /* Refresh, accept single keystroke of input */
3298                 key = wgetch(status_win);
3299                 switch (key) {
3300                 case KEY_RETURN:
3301                 case KEY_ENTER:
3302                 case '\n':
3303                         status = pos ? STOP : CANCEL;
3304                         break;
3305
3306                 case KEY_BACKSPACE:
3307                         if (pos > 0)
3308                                 pos--;
3309                         else
3310                                 status = CANCEL;
3311                         break;
3312
3313                 case KEY_ESC:
3314                         status = CANCEL;
3315                         break;
3316
3317                 case ERR:
3318                         break;
3319
3320                 default:
3321                         if (pos >= sizeof(buf)) {
3322                                 report("Input string too long");
3323                                 return NULL;
3324                         }
3325
3326                         if (isprint(key))
3327                                 buf[pos++] = (char) key;
3328                 }
3329         }
3330
3331         if (status == CANCEL) {
3332                 /* Clear the status window */
3333                 report("");
3334                 return NULL;
3335         }
3336
3337         buf[pos++] = 0;
3338
3339         return buf;
3340 }
3341
3342 /*
3343  * Repository references
3344  */
3345
3346 static struct ref *refs;
3347 static size_t refs_size;
3348
3349 /* Id <-> ref store */
3350 static struct ref ***id_refs;
3351 static size_t id_refs_size;
3352
3353 static struct ref **
3354 get_refs(char *id)
3355 {
3356         struct ref ***tmp_id_refs;
3357         struct ref **ref_list = NULL;
3358         size_t ref_list_size = 0;
3359         size_t i;
3360
3361         for (i = 0; i < id_refs_size; i++)
3362                 if (!strcmp(id, id_refs[i][0]->id))
3363                         return id_refs[i];
3364
3365         tmp_id_refs = realloc(id_refs, (id_refs_size + 1) * sizeof(*id_refs));
3366         if (!tmp_id_refs)
3367                 return NULL;
3368
3369         id_refs = tmp_id_refs;
3370
3371         for (i = 0; i < refs_size; i++) {
3372                 struct ref **tmp;
3373
3374                 if (strcmp(id, refs[i].id))
3375                         continue;
3376
3377                 tmp = realloc(ref_list, (ref_list_size + 1) * sizeof(*ref_list));
3378                 if (!tmp) {
3379                         if (ref_list)
3380                                 free(ref_list);
3381                         return NULL;
3382                 }
3383
3384                 ref_list = tmp;
3385                 if (ref_list_size > 0)
3386                         ref_list[ref_list_size - 1]->next = 1;
3387                 ref_list[ref_list_size] = &refs[i];
3388
3389                 /* XXX: The properties of the commit chains ensures that we can
3390                  * safely modify the shared ref. The repo references will
3391                  * always be similar for the same id. */
3392                 ref_list[ref_list_size]->next = 0;
3393                 ref_list_size++;
3394         }
3395
3396         if (ref_list)
3397                 id_refs[id_refs_size++] = ref_list;
3398
3399         return ref_list;
3400 }
3401
3402 static int
3403 read_ref(char *id, int idlen, char *name, int namelen)
3404 {
3405         struct ref *ref;
3406         bool tag = FALSE;
3407
3408         if (!strncmp(name, "refs/tags/", STRING_SIZE("refs/tags/"))) {
3409                 /* Commits referenced by tags has "^{}" appended. */
3410                 if (name[namelen - 1] != '}')
3411                         return OK;
3412
3413                 while (namelen > 0 && name[namelen] != '^')
3414                         namelen--;
3415
3416                 tag = TRUE;
3417                 namelen -= STRING_SIZE("refs/tags/");
3418                 name    += STRING_SIZE("refs/tags/");
3419
3420         } else if (!strncmp(name, "refs/heads/", STRING_SIZE("refs/heads/"))) {
3421                 namelen -= STRING_SIZE("refs/heads/");
3422                 name    += STRING_SIZE("refs/heads/");
3423
3424         } else if (!strcmp(name, "HEAD")) {
3425                 return OK;
3426         }
3427
3428         refs = realloc(refs, sizeof(*refs) * (refs_size + 1));
3429         if (!refs)
3430                 return ERR;
3431
3432         ref = &refs[refs_size++];
3433         ref->name = malloc(namelen + 1);
3434         if (!ref->name)
3435                 return ERR;
3436
3437         strncpy(ref->name, name, namelen);
3438         ref->name[namelen] = 0;
3439         ref->tag = tag;
3440         string_copy(ref->id, id);
3441
3442         return OK;
3443 }
3444
3445 static int
3446 load_refs(void)
3447 {
3448         const char *cmd_env = getenv("TIG_LS_REMOTE");
3449         const char *cmd = cmd_env && *cmd_env ? cmd_env : TIG_LS_REMOTE;
3450
3451         return read_properties(popen(cmd, "r"), "\t", read_ref);
3452 }
3453
3454 static int
3455 read_repo_config_option(char *name, int namelen, char *value, int valuelen)
3456 {
3457         if (!strcmp(name, "i18n.commitencoding"))
3458                 string_copy(opt_encoding, value);
3459
3460         return OK;
3461 }
3462
3463 static int
3464 load_repo_config(void)
3465 {
3466         return read_properties(popen("git repo-config --list", "r"),
3467                                "=", read_repo_config_option);
3468 }
3469
3470 static int
3471 read_properties(FILE *pipe, const char *separators,
3472                 int (*read_property)(char *, int, char *, int))
3473 {
3474         char buffer[BUFSIZ];
3475         char *name;
3476         int state = OK;
3477
3478         if (!pipe)
3479                 return ERR;
3480
3481         while (state == OK && (name = fgets(buffer, sizeof(buffer), pipe))) {
3482                 char *value;
3483                 size_t namelen;
3484                 size_t valuelen;
3485
3486                 name = chomp_string(name);
3487                 namelen = strcspn(name, separators);
3488
3489                 if (name[namelen]) {
3490                         name[namelen] = 0;
3491                         value = chomp_string(name + namelen + 1);
3492                         valuelen = strlen(value);
3493
3494                 } else {
3495                         value = "";
3496                         valuelen = 0;
3497                 }
3498
3499                 state = read_property(name, namelen, value, valuelen);
3500         }
3501
3502         if (state != ERR && ferror(pipe))
3503                 state = ERR;
3504
3505         pclose(pipe);
3506
3507         return state;
3508 }
3509
3510
3511 /*
3512  * Main
3513  */
3514
3515 static void __NORETURN
3516 quit(int sig)
3517 {
3518         /* XXX: Restore tty modes and let the OS cleanup the rest! */
3519         if (cursed)
3520                 endwin();
3521         exit(0);
3522 }
3523
3524 static void __NORETURN
3525 die(const char *err, ...)
3526 {
3527         va_list args;
3528
3529         endwin();
3530
3531         va_start(args, err);
3532         fputs("tig: ", stderr);
3533         vfprintf(stderr, err, args);
3534         fputs("\n", stderr);
3535         va_end(args);
3536
3537         exit(1);
3538 }
3539
3540 int
3541 main(int argc, char *argv[])
3542 {
3543         struct view *view;
3544         enum request request;
3545         size_t i;
3546
3547         signal(SIGINT, quit);
3548
3549         if (setlocale(LC_ALL, "")) {
3550                 string_copy(opt_codeset, nl_langinfo(CODESET));
3551         }
3552
3553         if (load_options() == ERR)
3554                 die("Failed to load user config.");
3555
3556         /* Load the repo config file so options can be overwritten from
3557          * the command line.  */
3558         if (load_repo_config() == ERR)
3559                 die("Failed to load repo config.");
3560
3561         if (!parse_options(argc, argv))
3562                 return 0;
3563
3564         if (*opt_codeset && strcmp(opt_codeset, opt_encoding)) {
3565                 opt_iconv = iconv_open(opt_codeset, opt_encoding);
3566                 if (opt_iconv == ICONV_NONE)
3567                         die("Failed to initialize character set conversion");
3568         }
3569
3570         if (load_refs() == ERR)
3571                 die("Failed to load refs.");
3572
3573         /* Require a git repository unless when running in pager mode. */
3574         if (refs_size == 0 && opt_request != REQ_VIEW_PAGER)
3575                 die("Not a git repository");
3576
3577         for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
3578                 view->cmd_env = getenv(view->cmd_env);
3579
3580         request = opt_request;
3581
3582         init_display();
3583
3584         while (view_driver(display[current_view], request)) {
3585                 int key;
3586                 int i;
3587
3588                 foreach_view (view, i)
3589                         update_view(view);
3590
3591                 /* Refresh, accept single keystroke of input */
3592                 key = wgetch(status_win);
3593
3594                 request = get_keybinding(display[current_view]->keymap, key);
3595
3596                 /* Some low-level request handling. This keeps access to
3597                  * status_win restricted. */
3598                 switch (request) {
3599                 case REQ_PROMPT:
3600                 {
3601                         char *cmd = read_prompt(":");
3602
3603                         if (cmd && string_format(opt_cmd, "git %s", cmd)) {
3604                                 if (strncmp(cmd, "show", 4) && isspace(cmd[4])) {
3605                                         opt_request = REQ_VIEW_DIFF;
3606                                 } else {
3607                                         opt_request = REQ_VIEW_PAGER;
3608                                 }
3609                                 break;
3610                         }
3611
3612                         request = REQ_NONE;
3613                         break;
3614                 }
3615                 case REQ_SEARCH:
3616                 case REQ_SEARCH_BACK:
3617                 {
3618                         const char *prompt = request == REQ_SEARCH
3619                                            ? "/" : "?";
3620                         char *search = read_prompt(prompt);
3621
3622                         if (search)
3623                                 string_copy(opt_search, search);
3624                         else
3625                                 request = REQ_NONE;
3626                         break;
3627                 }
3628                 case REQ_SCREEN_RESIZE:
3629                 {
3630                         int height, width;
3631
3632                         getmaxyx(stdscr, height, width);
3633
3634                         /* Resize the status view and let the view driver take
3635                          * care of resizing the displayed views. */
3636                         wresize(status_win, 1, width);
3637                         mvwin(status_win, height - 1, 0);
3638                         wrefresh(status_win);
3639                         break;
3640                 }
3641                 default:
3642                         break;
3643                 }
3644         }
3645
3646         quit(0);
3647
3648         return 0;
3649 }