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