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

   1 /* Copyright (c) 2006 Jonas Fonseca <fonseca@diku.dk>
   2  *
   3  * This program is free software; you can redistribute it and/or
   4  * modify it under the terms of the GNU General Public License as
   5  * published by the Free Software Foundation; either version 2 of
   6  * the License, or (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  */
  13
  14 #ifndef VERSION
  15 #define VERSION "tig-0.4.git"
  16 #endif
  17
  18 #ifndef DEBUG
  19 #define NDEBUG
  20 #endif
  21
  22 #include <assert.h>
  23 #include <errno.h>
  24 #include <ctype.h>
  25 #include <signal.h>
  26 #include <stdarg.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <unistd.h>
  31 #include <time.h>
  32
  33 #include <sys/types.h>
  34 #include <regex.h>
  35
  36 #include <locale.h>
  37 #include <langinfo.h>
  38 #include <iconv.h>
  39
  40 #include <curses.h>
  41
  42 #if __GNUC__ >= 3
  43 #define __NORETURN __attribute__((__noreturn__))
  44 #else
  45 #define __NORETURN
  46 #endif
  47
  48 static void __NORETURN die(const char *err, ...);
  49 static void report(const char *msg, ...);
  50 static int read_properties(FILE *pipe, const char *separators, int (*read)(char *, int, char *, int));
  51 static void set_nonblocking_input(bool loading);
  52 static size_t utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed);
  53
  54 #define ABS(x)          ((x) >= 0  ? (x) : -(x))
  55 #define MIN(x, y)       ((x) < (y) ? (x) :  (y))
  56
  57 #define ARRAY_SIZE(x)   (sizeof(x) / sizeof(x[0]))
  58 #define STRING_SIZE(x)  (sizeof(x) - 1)
  59
  60 #define SIZEOF_STR      1024    /* Default string size. */
  61 #define SIZEOF_REF      256     /* Size of symbolic or SHA1 ID. */
  62 #define SIZEOF_REV      41      /* Holds a SHA-1 and an ending NUL */
  63 #define SIZEOF_REVGRAPH 19      /* Size of revision ancestry graphics. */
  64
  65 /* 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, "-l")) {
 455                         opt_request = REQ_VIEW_LOG;
 456                         continue;
 457                 }
 458
 459                 if (!strcmp(opt, "-d")) {
 460                         opt_request = REQ_VIEW_DIFF;
 461                         continue;
 462                 }
 463
 464                 if (check_option(opt, 'n', "line-number", OPT_INT, &opt_num_interval)) {
 465                         opt_line_number = TRUE;
 466                         continue;
 467                 }
 468
 469                 if (check_option(opt, 'b', "tab-size", OPT_INT, &opt_tab_size)) {
 470                         opt_tab_size = MIN(opt_tab_size, TABSIZE);
 471                         continue;
 472                 }
 473
 474                 if (check_option(opt, 'v', "version", OPT_NONE)) {
 475                         printf("tig version %s\n", VERSION);
 476                         return FALSE;
 477                 }
 478
 479                 if (check_option(opt, 'h', "help", OPT_NONE)) {
 480                         printf(usage);
 481                         return FALSE;
 482                 }
 483
 484                 if (!strcmp(opt, "--")) {
 485                         i++;
 486                         break;
 487                 }
 488
 489                 if (!strcmp(opt, "log") ||
 490                     !strcmp(opt, "diff") ||
 491                     !strcmp(opt, "show")) {
 492                         opt_request = opt[0] == 'l'
 493                                     ? REQ_VIEW_LOG : REQ_VIEW_DIFF;
 494                         break;
 495                 }
 496
 497                 if (opt[0] && opt[0] != '-')
 498                         break;
 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 #define foreach_displayed_view(view, i) \
1168         for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
1169
1170 #define displayed_views()       (display[1] != NULL ? 2 : 1)
1171
1172 /* Current head and commit ID */
1173 static char ref_blob[SIZEOF_REF]        = "";
1174 static char ref_commit[SIZEOF_REF]      = "HEAD";
1175 static char ref_head[SIZEOF_REF]        = "HEAD";
1176
1177 struct view {
1178         const char *name;       /* View name */
1179         const char *cmd_fmt;    /* Default command line format */
1180         const char *cmd_env;    /* Command line set via environment */
1181         const char *id;         /* Points to either of ref_{head,commit,blob} */
1182
1183         struct view_ops *ops;   /* View operations */
1184
1185         enum keymap keymap;     /* What keymap does this view have */
1186
1187         char cmd[SIZEOF_STR];   /* Command buffer */
1188         char ref[SIZEOF_REF];   /* Hovered commit reference */
1189         char vid[SIZEOF_REF];   /* View ID. Set to id member when updating. */
1190
1191         int height, width;      /* The width and height of the main window */
1192         WINDOW *win;            /* The main window */
1193         WINDOW *title;          /* The title window living below the main window */
1194
1195         /* Navigation */
1196         unsigned long offset;   /* Offset of the window top */
1197         unsigned long lineno;   /* Current line number */
1198
1199         /* Searching */
1200         char grep[SIZEOF_STR];  /* Search string */
1201         regex_t *regex;         /* Pre-compiled regex */
1202
1203         /* If non-NULL, points to the view that opened this view. If this view
1204          * is closed tig will switch back to the parent view. */
1205         struct view *parent;
1206
1207         /* Buffering */
1208         unsigned long lines;    /* Total number of lines */
1209         struct line *line;      /* Line index */
1210         unsigned long line_size;/* Total number of allocated lines */
1211         unsigned int digits;    /* Number of digits in the lines member. */
1212
1213         /* Loading */
1214         FILE *pipe;
1215         time_t start_time;
1216 };
1217
1218 struct view_ops {
1219         /* What type of content being displayed. Used in the title bar. */
1220         const char *type;
1221         /* Draw one line; @lineno must be < view->height. */
1222         bool (*draw)(struct view *view, struct line *line, unsigned int lineno, bool selected);
1223         /* Read one line; updates view->line. */
1224         bool (*read)(struct view *view, char *data);
1225         /* Depending on view, change display based on current line. */
1226         bool (*enter)(struct view *view, struct line *line);
1227         /* Search for regex in a line. */
1228         bool (*grep)(struct view *view, struct line *line);
1229         /* Select line */
1230         void (*select)(struct view *view, struct line *line);
1231 };
1232
1233 static struct view_ops pager_ops;
1234 static struct view_ops main_ops;
1235 static struct view_ops tree_ops;
1236 static struct view_ops blob_ops;
1237
1238 #define VIEW_STR(name, cmd, env, ref, ops, map) \
1239         { name, cmd, #env, ref, ops, map}
1240
1241 #define VIEW_(id, name, ops, ref) \
1242         VIEW_STR(name, TIG_##id##_CMD,  TIG_##id##_CMD, ref, ops, KEYMAP_##id)
1243
1244
1245 static struct view views[] = {
1246         VIEW_(MAIN,  "main",  &main_ops,  ref_head),
1247         VIEW_(DIFF,  "diff",  &pager_ops, ref_commit),
1248         VIEW_(LOG,   "log",   &pager_ops, ref_head),
1249         VIEW_(TREE,  "tree",  &tree_ops,  ref_commit),
1250         VIEW_(BLOB,  "blob",  &blob_ops,  ref_blob),
1251         VIEW_(HELP,  "help",  &pager_ops, "static"),
1252         VIEW_(PAGER, "pager", &pager_ops, "static"),
1253 };
1254
1255 #define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
1256
1257 #define foreach_view(view, i) \
1258         for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
1259
1260 #define view_is_displayed(view) \
1261         (view == display[0] || view == display[1])
1262
1263 static bool
1264 draw_view_line(struct view *view, unsigned int lineno)
1265 {
1266         struct line *line;
1267         bool selected = (view->offset + lineno == view->lineno);
1268
1269         assert(view_is_displayed(view));
1270
1271         if (view->offset + lineno >= view->lines)
1272                 return FALSE;
1273
1274         line = &view->line[view->offset + lineno];
1275
1276         if (selected) {
1277                 line->selected = TRUE;
1278                 view->ops->select(view, line);
1279         } else if (line->selected) {
1280                 line->selected = FALSE;
1281                 wmove(view->win, lineno, 0);
1282                 wclrtoeol(view->win);
1283         }
1284
1285         return view->ops->draw(view, line, lineno, selected);
1286 }
1287
1288 static void
1289 redraw_view_from(struct view *view, int lineno)
1290 {
1291         assert(0 <= lineno && lineno < view->height);
1292
1293         for (; lineno < view->height; lineno++) {
1294                 if (!draw_view_line(view, lineno))
1295                         break;
1296         }
1297
1298         redrawwin(view->win);
1299         wrefresh(view->win);
1300 }
1301
1302 static void
1303 redraw_view(struct view *view)
1304 {
1305         wclear(view->win);
1306         redraw_view_from(view, 0);
1307 }
1308
1309
1310 static void
1311 update_view_title(struct view *view)
1312 {
1313         assert(view_is_displayed(view));
1314
1315         if (view == display[current_view])
1316                 wbkgdset(view->title, get_line_attr(LINE_TITLE_FOCUS));
1317         else
1318                 wbkgdset(view->title, get_line_attr(LINE_TITLE_BLUR));
1319
1320         werase(view->title);
1321         wmove(view->title, 0, 0);
1322
1323         if (*view->ref)
1324                 wprintw(view->title, "[%s] %s", view->name, view->ref);
1325         else
1326                 wprintw(view->title, "[%s]", view->name);
1327
1328         if (view->lines || view->pipe) {
1329                 unsigned int view_lines = view->offset + view->height;
1330                 unsigned int lines = view->lines
1331                                    ? MIN(view_lines, view->lines) * 100 / view->lines
1332                                    : 0;
1333
1334                 wprintw(view->title, " - %s %d of %d (%d%%)",
1335                         view->ops->type,
1336                         view->lineno + 1,
1337                         view->lines,
1338                         lines);
1339         }
1340
1341         if (view->pipe) {
1342                 time_t secs = time(NULL) - view->start_time;
1343
1344                 /* Three git seconds are a long time ... */
1345                 if (secs > 2)
1346                         wprintw(view->title, " %lds", secs);
1347         }
1348
1349         wmove(view->title, 0, view->width - 1);
1350         wrefresh(view->title);
1351 }
1352
1353 static void
1354 resize_display(void)
1355 {
1356         int offset, i;
1357         struct view *base = display[0];
1358         struct view *view = display[1] ? display[1] : display[0];
1359
1360         /* Setup window dimensions */
1361
1362         getmaxyx(stdscr, base->height, base->width);
1363
1364         /* Make room for the status window. */
1365         base->height -= 1;
1366
1367         if (view != base) {
1368                 /* Horizontal split. */
1369                 view->width   = base->width;
1370                 view->height  = SCALE_SPLIT_VIEW(base->height);
1371                 base->height -= view->height;
1372
1373                 /* Make room for the title bar. */
1374                 view->height -= 1;
1375         }
1376
1377         /* Make room for the title bar. */
1378         base->height -= 1;
1379
1380         offset = 0;
1381
1382         foreach_displayed_view (view, i) {
1383                 if (!view->win) {
1384                         view->win = newwin(view->height, 0, offset, 0);
1385                         if (!view->win)
1386                                 die("Failed to create %s view", view->name);
1387
1388                         scrollok(view->win, TRUE);
1389
1390                         view->title = newwin(1, 0, offset + view->height, 0);
1391                         if (!view->title)
1392                                 die("Failed to create title window");
1393
1394                 } else {
1395                         wresize(view->win, view->height, view->width);
1396                         mvwin(view->win,   offset, 0);
1397                         mvwin(view->title, offset + view->height, 0);
1398                 }
1399
1400                 offset += view->height + 1;
1401         }
1402 }
1403
1404 static void
1405 redraw_display(void)
1406 {
1407         struct view *view;
1408         int i;
1409
1410         foreach_displayed_view (view, i) {
1411                 redraw_view(view);
1412                 update_view_title(view);
1413         }
1414 }
1415
1416 static void
1417 update_display_cursor(void)
1418 {
1419         struct view *view = display[current_view];
1420
1421         /* Move the cursor to the right-most column of the cursor line.
1422          *
1423          * XXX: This could turn out to be a bit expensive, but it ensures that
1424          * the cursor does not jump around. */
1425         if (view->lines) {
1426                 wmove(view->win, view->lineno - view->offset, view->width - 1);
1427                 wrefresh(view->win);
1428         }
1429 }
1430
1431 /*
1432  * Navigation
1433  */
1434
1435 /* Scrolling backend */
1436 static void
1437 do_scroll_view(struct view *view, int lines)
1438 {
1439         bool redraw_current_line = FALSE;
1440
1441         /* The rendering expects the new offset. */
1442         view->offset += lines;
1443
1444         assert(0 <= view->offset && view->offset < view->lines);
1445         assert(lines);
1446
1447         /* Move current line into the view. */
1448         if (view->lineno < view->offset) {
1449                 view->lineno = view->offset;
1450                 redraw_current_line = TRUE;
1451         } else if (view->lineno >= view->offset + view->height) {
1452                 view->lineno = view->offset + view->height - 1;
1453                 redraw_current_line = TRUE;
1454         }
1455
1456         assert(view->offset <= view->lineno && view->lineno < view->lines);
1457
1458         /* Redraw the whole screen if scrolling is pointless. */
1459         if (view->height < ABS(lines)) {
1460                 redraw_view(view);
1461
1462         } else {
1463                 int line = lines > 0 ? view->height - lines : 0;
1464                 int end = line + ABS(lines);
1465
1466                 wscrl(view->win, lines);
1467
1468                 for (; line < end; line++) {
1469                         if (!draw_view_line(view, line))
1470                                 break;
1471                 }
1472
1473                 if (redraw_current_line)
1474                         draw_view_line(view, view->lineno - view->offset);
1475         }
1476
1477         redrawwin(view->win);
1478         wrefresh(view->win);
1479         report("");
1480 }
1481
1482 /* Scroll frontend */
1483 static void
1484 scroll_view(struct view *view, enum request request)
1485 {
1486         int lines = 1;
1487
1488         assert(view_is_displayed(view));
1489
1490         switch (request) {
1491         case REQ_SCROLL_PAGE_DOWN:
1492                 lines = view->height;
1493         case REQ_SCROLL_LINE_DOWN:
1494                 if (view->offset + lines > view->lines)
1495                         lines = view->lines - view->offset;
1496
1497                 if (lines == 0 || view->offset + view->height >= view->lines) {
1498                         report("Cannot scroll beyond the last line");
1499                         return;
1500                 }
1501                 break;
1502
1503         case REQ_SCROLL_PAGE_UP:
1504                 lines = view->height;
1505         case REQ_SCROLL_LINE_UP:
1506                 if (lines > view->offset)
1507                         lines = view->offset;
1508
1509                 if (lines == 0) {
1510                         report("Cannot scroll beyond the first line");
1511                         return;
1512                 }
1513
1514                 lines = -lines;
1515                 break;
1516
1517         default:
1518                 die("request %d not handled in switch", request);
1519         }
1520
1521         do_scroll_view(view, lines);
1522 }
1523
1524 /* Cursor moving */
1525 static void
1526 move_view(struct view *view, enum request request)
1527 {
1528         int scroll_steps = 0;
1529         int steps;
1530
1531         switch (request) {
1532         case REQ_MOVE_FIRST_LINE:
1533                 steps = -view->lineno;
1534                 break;
1535
1536         case REQ_MOVE_LAST_LINE:
1537                 steps = view->lines - view->lineno - 1;
1538                 break;
1539
1540         case REQ_MOVE_PAGE_UP:
1541                 steps = view->height > view->lineno
1542                       ? -view->lineno : -view->height;
1543                 break;
1544
1545         case REQ_MOVE_PAGE_DOWN:
1546                 steps = view->lineno + view->height >= view->lines
1547                       ? view->lines - view->lineno - 1 : view->height;
1548                 break;
1549
1550         case REQ_MOVE_UP:
1551                 steps = -1;
1552                 break;
1553
1554         case REQ_MOVE_DOWN:
1555                 steps = 1;
1556                 break;
1557
1558         default:
1559                 die("request %d not handled in switch", request);
1560         }
1561
1562         if (steps <= 0 && view->lineno == 0) {
1563                 report("Cannot move beyond the first line");
1564                 return;
1565
1566         } else if (steps >= 0 && view->lineno + 1 >= view->lines) {
1567                 report("Cannot move beyond the last line");
1568                 return;
1569         }
1570
1571         /* Move the current line */
1572         view->lineno += steps;
1573         assert(0 <= view->lineno && view->lineno < view->lines);
1574
1575         /* Check whether the view needs to be scrolled */
1576         if (view->lineno < view->offset ||
1577             view->lineno >= view->offset + view->height) {
1578                 scroll_steps = steps;
1579                 if (steps < 0 && -steps > view->offset) {
1580                         scroll_steps = -view->offset;
1581
1582                 } else if (steps > 0) {
1583                         if (view->lineno == view->lines - 1 &&
1584                             view->lines > view->height) {
1585                                 scroll_steps = view->lines - view->offset - 1;
1586                                 if (scroll_steps >= view->height)
1587                                         scroll_steps -= view->height - 1;
1588                         }
1589                 }
1590         }
1591
1592         if (!view_is_displayed(view)) {
1593                 view->offset += steps;
1594                 view->ops->select(view, &view->line[view->lineno]);
1595                 return;
1596         }
1597
1598         /* Repaint the old "current" line if we be scrolling */
1599         if (ABS(steps) < view->height)
1600                 draw_view_line(view, view->lineno - steps - view->offset);
1601
1602         if (scroll_steps) {
1603                 do_scroll_view(view, scroll_steps);
1604                 return;
1605         }
1606
1607         /* Draw the current line */
1608         draw_view_line(view, view->lineno - view->offset);
1609
1610         redrawwin(view->win);
1611         wrefresh(view->win);
1612         report("");
1613 }
1614
1615
1616 /*
1617  * Searching
1618  */
1619
1620 static void search_view(struct view *view, enum request request);
1621
1622 static bool
1623 find_next_line(struct view *view, unsigned long lineno, struct line *line)
1624 {
1625         assert(view_is_displayed(view));
1626
1627         if (!view->ops->grep(view, line))
1628                 return FALSE;
1629
1630         if (lineno - view->offset >= view->height) {
1631                 view->offset = lineno;
1632                 view->lineno = lineno;
1633                 redraw_view(view);
1634
1635         } else {
1636                 unsigned long old_lineno = view->lineno - view->offset;
1637
1638                 view->lineno = lineno;
1639                 draw_view_line(view, old_lineno);
1640
1641                 draw_view_line(view, view->lineno - view->offset);
1642                 redrawwin(view->win);
1643                 wrefresh(view->win);
1644         }
1645
1646         report("Line %ld matches '%s'", lineno + 1, view->grep);
1647         return TRUE;
1648 }
1649
1650 static void
1651 find_next(struct view *view, enum request request)
1652 {
1653         unsigned long lineno = view->lineno;
1654         int direction;
1655
1656         if (!*view->grep) {
1657                 if (!*opt_search)
1658                         report("No previous search");
1659                 else
1660                         search_view(view, request);
1661                 return;
1662         }
1663
1664         switch (request) {
1665         case REQ_SEARCH:
1666         case REQ_FIND_NEXT:
1667                 direction = 1;
1668                 break;
1669
1670         case REQ_SEARCH_BACK:
1671         case REQ_FIND_PREV:
1672                 direction = -1;
1673                 break;
1674
1675         default:
1676                 return;
1677         }
1678
1679         if (request == REQ_FIND_NEXT || request == REQ_FIND_PREV)
1680                 lineno += direction;
1681
1682         /* Note, lineno is unsigned long so will wrap around in which case it
1683          * will become bigger than view->lines. */
1684         for (; lineno < view->lines; lineno += direction) {
1685                 struct line *line = &view->line[lineno];
1686
1687                 if (find_next_line(view, lineno, line))
1688                         return;
1689         }
1690
1691         report("No match found for '%s'", view->grep);
1692 }
1693
1694 static void
1695 search_view(struct view *view, enum request request)
1696 {
1697         int regex_err;
1698
1699         if (view->regex) {
1700                 regfree(view->regex);
1701                 *view->grep = 0;
1702         } else {
1703                 view->regex = calloc(1, sizeof(*view->regex));
1704                 if (!view->regex)
1705                         return;
1706         }
1707
1708         regex_err = regcomp(view->regex, opt_search, REG_EXTENDED);
1709         if (regex_err != 0) {
1710                 char buf[SIZEOF_STR] = "unknown error";
1711
1712                 regerror(regex_err, view->regex, buf, sizeof(buf));
1713                 report("Search failed: %s", buf);
1714                 return;
1715         }
1716
1717         string_copy(view->grep, opt_search);
1718
1719         find_next(view, request);
1720 }
1721
1722 /*
1723  * Incremental updating
1724  */
1725
1726 static void
1727 end_update(struct view *view)
1728 {
1729         if (!view->pipe)
1730                 return;
1731         set_nonblocking_input(FALSE);
1732         if (view->pipe == stdin)
1733                 fclose(view->pipe);
1734         else
1735                 pclose(view->pipe);
1736         view->pipe = NULL;
1737 }
1738
1739 static bool
1740 begin_update(struct view *view)
1741 {
1742         const char *id = view->id;
1743
1744         if (view->pipe)
1745                 end_update(view);
1746
1747         if (opt_cmd[0]) {
1748                 string_copy(view->cmd, opt_cmd);
1749                 opt_cmd[0] = 0;
1750                 /* When running random commands, the view ref could have become
1751                  * invalid so clear it. */
1752                 view->ref[0] = 0;
1753
1754         } else if (view == VIEW(REQ_VIEW_TREE)) {
1755                 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
1756
1757                 if (strcmp(view->vid, view->id))
1758                         opt_path[0] = 0;
1759
1760                 if (!string_format(view->cmd, format, id, opt_path))
1761                         return FALSE;
1762
1763         } else {
1764                 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
1765
1766                 if (!string_format(view->cmd, format, id, id, id, id, id))
1767                         return FALSE;
1768         }
1769
1770         /* Special case for the pager view. */
1771         if (opt_pipe) {
1772                 view->pipe = opt_pipe;
1773                 opt_pipe = NULL;
1774         } else {
1775                 view->pipe = popen(view->cmd, "r");
1776         }
1777
1778         if (!view->pipe)
1779                 return FALSE;
1780
1781         set_nonblocking_input(TRUE);
1782
1783         view->offset = 0;
1784         view->lines  = 0;
1785         view->lineno = 0;
1786         string_copy(view->vid, id);
1787
1788         if (view->line) {
1789                 int i;
1790
1791                 for (i = 0; i < view->lines; i++)
1792                         if (view->line[i].data)
1793                                 free(view->line[i].data);
1794
1795                 free(view->line);
1796                 view->line = NULL;
1797         }
1798
1799         view->start_time = time(NULL);
1800
1801         return TRUE;
1802 }
1803
1804 static struct line *
1805 realloc_lines(struct view *view, size_t line_size)
1806 {
1807         struct line *tmp = realloc(view->line, sizeof(*view->line) * line_size);
1808
1809         if (!tmp)
1810                 return NULL;
1811
1812         view->line = tmp;
1813         view->line_size = line_size;
1814         return view->line;
1815 }
1816
1817 static bool
1818 update_view(struct view *view)
1819 {
1820         char in_buffer[BUFSIZ];
1821         char out_buffer[BUFSIZ * 2];
1822         char *line;
1823         /* The number of lines to read. If too low it will cause too much
1824          * redrawing (and possible flickering), if too high responsiveness
1825          * will suffer. */
1826         unsigned long lines = view->height;
1827         int redraw_from = -1;
1828
1829         if (!view->pipe)
1830                 return TRUE;
1831
1832         /* Only redraw if lines are visible. */
1833         if (view->offset + view->height >= view->lines)
1834                 redraw_from = view->lines - view->offset;
1835
1836         /* FIXME: This is probably not perfect for backgrounded views. */
1837         if (!realloc_lines(view, view->lines + lines))
1838                 goto alloc_error;
1839
1840         while ((line = fgets(in_buffer, sizeof(in_buffer), view->pipe))) {
1841                 size_t linelen = strlen(line);
1842
1843                 if (linelen)
1844                         line[linelen - 1] = 0;
1845
1846                 if (opt_iconv != ICONV_NONE) {
1847                         char *inbuf = line;
1848                         size_t inlen = linelen;
1849
1850                         char *outbuf = out_buffer;
1851                         size_t outlen = sizeof(out_buffer);
1852
1853                         size_t ret;
1854
1855                         ret = iconv(opt_iconv, &inbuf, &inlen, &outbuf, &outlen);
1856                         if (ret != (size_t) -1) {
1857                                 line = out_buffer;
1858                                 linelen = strlen(out_buffer);
1859                         }
1860                 }
1861
1862                 if (!view->ops->read(view, line))
1863                         goto alloc_error;
1864
1865                 if (lines-- == 1)
1866                         break;
1867         }
1868
1869         {
1870                 int digits;
1871
1872                 lines = view->lines;
1873                 for (digits = 0; lines; digits++)
1874                         lines /= 10;
1875
1876                 /* Keep the displayed view in sync with line number scaling. */
1877                 if (digits != view->digits) {
1878                         view->digits = digits;
1879                         redraw_from = 0;
1880                 }
1881         }
1882
1883         if (!view_is_displayed(view))
1884                 goto check_pipe;
1885
1886         if (view == VIEW(REQ_VIEW_TREE)) {
1887                 /* Clear the view and redraw everything since the tree sorting
1888                  * might have rearranged things. */
1889                 redraw_view(view);
1890
1891         } else if (redraw_from >= 0) {
1892                 /* If this is an incremental update, redraw the previous line
1893                  * since for commits some members could have changed when
1894                  * loading the main view. */
1895                 if (redraw_from > 0)
1896                         redraw_from--;
1897
1898                 /* Incrementally draw avoids flickering. */
1899                 redraw_view_from(view, redraw_from);
1900         }
1901
1902         /* Update the title _after_ the redraw so that if the redraw picks up a
1903          * commit reference in view->ref it'll be available here. */
1904         update_view_title(view);
1905
1906 check_pipe:
1907         if (ferror(view->pipe)) {
1908                 report("Failed to read: %s", strerror(errno));
1909                 goto end;
1910
1911         } else if (feof(view->pipe)) {
1912                 report("");
1913                 goto end;
1914         }
1915
1916         return TRUE;
1917
1918 alloc_error:
1919         report("Allocation failure");
1920
1921 end:
1922         end_update(view);
1923         return FALSE;
1924 }
1925
1926
1927 /*
1928  * View opening
1929  */
1930
1931 static void open_help_view(struct view *view)
1932 {
1933         char buf[BUFSIZ];
1934         int lines = ARRAY_SIZE(req_info) + 2;
1935         int i;
1936
1937         if (view->lines > 0)
1938                 return;
1939
1940         for (i = 0; i < ARRAY_SIZE(req_info); i++)
1941                 if (!req_info[i].request)
1942                         lines++;
1943
1944         view->line = calloc(lines, sizeof(*view->line));
1945         if (!view->line) {
1946                 report("Allocation failure");
1947                 return;
1948         }
1949
1950         view->ops->read(view, "Quick reference for tig keybindings:");
1951
1952         for (i = 0; i < ARRAY_SIZE(req_info); i++) {
1953                 char *key;
1954
1955                 if (!req_info[i].request) {
1956                         view->ops->read(view, "");
1957                         view->ops->read(view, req_info[i].help);
1958                         continue;
1959                 }
1960
1961                 key = get_key(req_info[i].request);
1962                 if (!string_format(buf, "%-25s %s", key, req_info[i].help))
1963                         continue;
1964
1965                 view->ops->read(view, buf);
1966         }
1967 }
1968
1969 enum open_flags {
1970         OPEN_DEFAULT = 0,       /* Use default view switching. */
1971         OPEN_SPLIT = 1,         /* Split current view. */
1972         OPEN_BACKGROUNDED = 2,  /* Backgrounded. */
1973         OPEN_RELOAD = 4,        /* Reload view even if it is the current. */
1974 };
1975
1976 static void
1977 open_view(struct view *prev, enum request request, enum open_flags flags)
1978 {
1979         bool backgrounded = !!(flags & OPEN_BACKGROUNDED);
1980         bool split = !!(flags & OPEN_SPLIT);
1981         bool reload = !!(flags & OPEN_RELOAD);
1982         struct view *view = VIEW(request);
1983         int nviews = displayed_views();
1984         struct view *base_view = display[0];
1985
1986         if (view == prev && nviews == 1 && !reload) {
1987                 report("Already in %s view", view->name);
1988                 return;
1989         }
1990
1991         if (view == VIEW(REQ_VIEW_HELP)) {
1992                 open_help_view(view);
1993
1994         } else if ((reload || strcmp(view->vid, view->id)) &&
1995                    !begin_update(view)) {
1996                 report("Failed to load %s view", view->name);
1997                 return;
1998         }
1999
2000         if (split) {
2001                 display[1] = view;
2002                 if (!backgrounded)
2003                         current_view = 1;
2004         } else {
2005                 /* Maximize the current view. */
2006                 memset(display, 0, sizeof(display));
2007                 current_view = 0;
2008                 display[current_view] = view;
2009         }
2010
2011         /* Resize the view when switching between split- and full-screen,
2012          * or when switching between two different full-screen views. */
2013         if (nviews != displayed_views() ||
2014             (nviews == 1 && base_view != display[0]))
2015                 resize_display();
2016
2017         if (split && prev->lineno - prev->offset >= prev->height) {
2018                 /* Take the title line into account. */
2019                 int lines = prev->lineno - prev->offset - prev->height + 1;
2020
2021                 /* Scroll the view that was split if the current line is
2022                  * outside the new limited view. */
2023                 do_scroll_view(prev, lines);
2024         }
2025
2026         if (prev && view != prev) {
2027                 if (split && !backgrounded) {
2028                         /* "Blur" the previous view. */
2029                         update_view_title(prev);
2030                 }
2031
2032                 view->parent = prev;
2033         }
2034
2035         if (view->pipe && view->lines == 0) {
2036                 /* Clear the old view and let the incremental updating refill
2037                  * the screen. */
2038                 wclear(view->win);
2039                 report("");
2040         } else {
2041                 redraw_view(view);
2042                 report("");
2043         }
2044
2045         /* If the view is backgrounded the above calls to report()
2046          * won't redraw the view title. */
2047         if (backgrounded)
2048                 update_view_title(view);
2049 }
2050
2051
2052 /*
2053  * User request switch noodle
2054  */
2055
2056 static int
2057 view_driver(struct view *view, enum request request)
2058 {
2059         int i;
2060
2061         switch (request) {
2062         case REQ_MOVE_UP:
2063         case REQ_MOVE_DOWN:
2064         case REQ_MOVE_PAGE_UP:
2065         case REQ_MOVE_PAGE_DOWN:
2066         case REQ_MOVE_FIRST_LINE:
2067         case REQ_MOVE_LAST_LINE:
2068                 move_view(view, request);
2069                 break;
2070
2071         case REQ_SCROLL_LINE_DOWN:
2072         case REQ_SCROLL_LINE_UP:
2073         case REQ_SCROLL_PAGE_DOWN:
2074         case REQ_SCROLL_PAGE_UP:
2075                 scroll_view(view, request);
2076                 break;
2077
2078         case REQ_VIEW_BLOB:
2079                 if (!ref_blob[0]) {
2080                         report("No file chosen, press 't' to open tree view");
2081                         break;
2082                 }
2083                 /* Fall-through */
2084         case REQ_VIEW_MAIN:
2085         case REQ_VIEW_DIFF:
2086         case REQ_VIEW_LOG:
2087         case REQ_VIEW_TREE:
2088         case REQ_VIEW_HELP:
2089         case REQ_VIEW_PAGER:
2090                 open_view(view, request, OPEN_DEFAULT);
2091                 break;
2092
2093         case REQ_NEXT:
2094         case REQ_PREVIOUS:
2095                 request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
2096
2097                 if ((view == VIEW(REQ_VIEW_DIFF) &&
2098                      view->parent == VIEW(REQ_VIEW_MAIN)) ||
2099                    (view == VIEW(REQ_VIEW_BLOB) &&
2100                      view->parent == VIEW(REQ_VIEW_TREE))) {
2101                         view = view->parent;
2102                         move_view(view, request);
2103                         if (view_is_displayed(view))
2104                                 update_view_title(view);
2105                 } else {
2106                         move_view(view, request);
2107                         break;
2108                 }
2109                 /* Fall-through */
2110
2111         case REQ_ENTER:
2112                 if (!view->lines) {
2113                         report("Nothing to enter");
2114                         break;
2115                 }
2116                 return view->ops->enter(view, &view->line[view->lineno]);
2117
2118         case REQ_VIEW_NEXT:
2119         {
2120                 int nviews = displayed_views();
2121                 int next_view = (current_view + 1) % nviews;
2122
2123                 if (next_view == current_view) {
2124                         report("Only one view is displayed");
2125                         break;
2126                 }
2127
2128                 current_view = next_view;
2129                 /* Blur out the title of the previous view. */
2130                 update_view_title(view);
2131                 report("");
2132                 break;
2133         }
2134         case REQ_TOGGLE_LINENO:
2135                 opt_line_number = !opt_line_number;
2136                 redraw_display();
2137                 break;
2138
2139         case REQ_TOGGLE_REV_GRAPH:
2140                 opt_rev_graph = !opt_rev_graph;
2141                 redraw_display();
2142                 break;
2143
2144         case REQ_PROMPT:
2145                 /* Always reload^Wrerun commands from the prompt. */
2146                 open_view(view, opt_request, OPEN_RELOAD);
2147                 break;
2148
2149         case REQ_SEARCH:
2150         case REQ_SEARCH_BACK:
2151                 search_view(view, request);
2152                 break;
2153
2154         case REQ_FIND_NEXT:
2155         case REQ_FIND_PREV:
2156                 find_next(view, request);
2157                 break;
2158
2159         case REQ_STOP_LOADING:
2160                 for (i = 0; i < ARRAY_SIZE(views); i++) {
2161                         view = &views[i];
2162                         if (view->pipe)
2163                                 report("Stopped loading the %s view", view->name),
2164                         end_update(view);
2165                 }
2166                 break;
2167
2168         case REQ_SHOW_VERSION:
2169                 report("%s (built %s)", VERSION, __DATE__);
2170                 return TRUE;
2171
2172         case REQ_SCREEN_RESIZE:
2173                 resize_display();
2174                 /* Fall-through */
2175         case REQ_SCREEN_REDRAW:
2176                 redraw_display();
2177                 break;
2178
2179         case REQ_NONE:
2180                 doupdate();
2181                 return TRUE;
2182
2183         case REQ_VIEW_CLOSE:
2184                 /* XXX: Mark closed views by letting view->parent point to the
2185                  * view itself. Parents to closed view should never be
2186                  * followed. */
2187                 if (view->parent &&
2188                     view->parent->parent != view->parent) {
2189                         memset(display, 0, sizeof(display));
2190                         current_view = 0;
2191                         display[current_view] = view->parent;
2192                         view->parent = view;
2193                         resize_display();
2194                         redraw_display();
2195                         break;
2196                 }
2197                 /* Fall-through */
2198         case REQ_QUIT:
2199                 return FALSE;
2200
2201         default:
2202                 /* An unknown key will show most commonly used commands. */
2203                 report("Unknown key, press 'h' for help");
2204                 return TRUE;
2205         }
2206
2207         return TRUE;
2208 }
2209
2210
2211 /*
2212  * Pager backend
2213  */
2214
2215 static bool
2216 pager_draw(struct view *view, struct line *line, unsigned int lineno, bool selected)
2217 {
2218         char *text = line->data;
2219         enum line_type type = line->type;
2220         int textlen = strlen(text);
2221         int attr;
2222
2223         wmove(view->win, lineno, 0);
2224
2225         if (selected) {
2226                 type = LINE_CURSOR;
2227                 wchgat(view->win, -1, 0, type, NULL);
2228         }
2229
2230         attr = get_line_attr(type);
2231         wattrset(view->win, attr);
2232
2233         if (opt_line_number || opt_tab_size < TABSIZE) {
2234                 static char spaces[] = "                    ";
2235                 int col_offset = 0, col = 0;
2236
2237                 if (opt_line_number) {
2238                         unsigned long real_lineno = view->offset + lineno + 1;
2239
2240                         if (real_lineno == 1 ||
2241                             (real_lineno % opt_num_interval) == 0) {
2242                                 wprintw(view->win, "%.*d", view->digits, real_lineno);
2243
2244                         } else {
2245                                 waddnstr(view->win, spaces,
2246                                          MIN(view->digits, STRING_SIZE(spaces)));
2247                         }
2248                         waddstr(view->win, ": ");
2249                         col_offset = view->digits + 2;
2250                 }
2251
2252                 while (text && col_offset + col < view->width) {
2253                         int cols_max = view->width - col_offset - col;
2254                         char *pos = text;
2255                         int cols;
2256
2257                         if (*text == '\t') {
2258                                 text++;
2259                                 assert(sizeof(spaces) > TABSIZE);
2260                                 pos = spaces;
2261                                 cols = opt_tab_size - (col % opt_tab_size);
2262
2263                         } else {
2264                                 text = strchr(text, '\t');
2265                                 cols = line ? text - pos : strlen(pos);
2266                         }
2267
2268                         waddnstr(view->win, pos, MIN(cols, cols_max));
2269                         col += cols;
2270                 }
2271
2272         } else {
2273                 int col = 0, pos = 0;
2274
2275                 for (; pos < textlen && col < view->width; pos++, col++)
2276                         if (text[pos] == '\t')
2277                                 col += TABSIZE - (col % TABSIZE) - 1;
2278
2279                 waddnstr(view->win, text, pos);
2280         }
2281
2282         return TRUE;
2283 }
2284
2285 static bool
2286 add_describe_ref(char *buf, size_t *bufpos, char *commit_id, const char *sep)
2287 {
2288         char refbuf[SIZEOF_STR];
2289         char *ref = NULL;
2290         FILE *pipe;
2291
2292         if (!string_format(refbuf, "git describe %s", commit_id))
2293                 return TRUE;
2294
2295         pipe = popen(refbuf, "r");
2296         if (!pipe)
2297                 return TRUE;
2298
2299         if ((ref = fgets(refbuf, sizeof(refbuf), pipe)))
2300                 ref = chomp_string(ref);
2301         pclose(pipe);
2302
2303         if (!ref || !*ref)
2304                 return TRUE;
2305
2306         /* This is the only fatal call, since it can "corrupt" the buffer. */
2307         if (!string_nformat(buf, SIZEOF_STR, bufpos, "%s%s", sep, ref))
2308                 return FALSE;
2309
2310         return TRUE;
2311 }
2312
2313 static void
2314 add_pager_refs(struct view *view, struct line *line)
2315 {
2316         char buf[SIZEOF_STR];
2317         char *commit_id = line->data + STRING_SIZE("commit ");
2318         struct ref **refs;
2319         size_t bufpos = 0, refpos = 0;
2320         const char *sep = "Refs: ";
2321         bool is_tag = FALSE;
2322
2323         assert(line->type == LINE_COMMIT);
2324
2325         refs = get_refs(commit_id);
2326         if (!refs) {
2327                 if (view == VIEW(REQ_VIEW_DIFF))
2328                         goto try_add_describe_ref;
2329                 return;
2330         }
2331
2332         do {
2333                 struct ref *ref = refs[refpos];
2334                 char *fmt = ref->tag ? "%s[%s]" : "%s%s";
2335
2336                 if (!string_format_from(buf, &bufpos, fmt, sep, ref->name))
2337                         return;
2338                 sep = ", ";
2339                 if (ref->tag)
2340                         is_tag = TRUE;
2341         } while (refs[refpos++]->next);
2342
2343         if (!is_tag && view == VIEW(REQ_VIEW_DIFF)) {
2344 try_add_describe_ref:
2345                 /* Add <tag>-g<commit_id> "fake" reference. */
2346                 if (!add_describe_ref(buf, &bufpos, commit_id, sep))
2347                         return;
2348         }
2349
2350         if (bufpos == 0)
2351                 return;
2352
2353         if (!realloc_lines(view, view->line_size + 1))
2354                 return;
2355
2356         line = &view->line[view->lines];
2357         line->data = strdup(buf);
2358         if (!line->data)
2359                 return;
2360
2361         line->type = LINE_PP_REFS;
2362         view->lines++;
2363 }
2364
2365 static bool
2366 pager_read(struct view *view, char *data)
2367 {
2368         struct line *line = &view->line[view->lines];
2369
2370         line->data = strdup(data);
2371         if (!line->data)
2372                 return FALSE;
2373
2374         line->type = get_line_type(line->data);
2375         view->lines++;
2376
2377         if (line->type == LINE_COMMIT &&
2378             (view == VIEW(REQ_VIEW_DIFF) ||
2379              view == VIEW(REQ_VIEW_LOG)))
2380                 add_pager_refs(view, line);
2381
2382         return TRUE;
2383 }
2384
2385 static bool
2386 pager_enter(struct view *view, struct line *line)
2387 {
2388         int split = 0;
2389
2390         if (line->type == LINE_COMMIT &&
2391            (view == VIEW(REQ_VIEW_LOG) ||
2392             view == VIEW(REQ_VIEW_PAGER))) {
2393                 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
2394                 split = 1;
2395         }
2396
2397         /* Always scroll the view even if it was split. That way
2398          * you can use Enter to scroll through the log view and
2399          * split open each commit diff. */
2400         scroll_view(view, REQ_SCROLL_LINE_DOWN);
2401
2402         /* FIXME: A minor workaround. Scrolling the view will call report("")
2403          * but if we are scrolling a non-current view this won't properly
2404          * update the view title. */
2405         if (split)
2406                 update_view_title(view);
2407
2408         return TRUE;
2409 }
2410
2411 static bool
2412 pager_grep(struct view *view, struct line *line)
2413 {
2414         regmatch_t pmatch;
2415         char *text = line->data;
2416
2417         if (!*text)
2418                 return FALSE;
2419
2420         if (regexec(view->regex, text, 1, &pmatch, 0) == REG_NOMATCH)
2421                 return FALSE;
2422
2423         return TRUE;
2424 }
2425
2426 static void
2427 pager_select(struct view *view, struct line *line)
2428 {
2429         if (line->type == LINE_COMMIT) {
2430                 char *text = line->data;
2431
2432                 string_copy(view->ref, text + STRING_SIZE("commit "));
2433                 string_copy(ref_commit, view->ref);
2434         }
2435 }
2436
2437 static struct view_ops pager_ops = {
2438         "line",
2439         pager_draw,
2440         pager_read,
2441         pager_enter,
2442         pager_grep,
2443         pager_select,
2444 };
2445
2446
2447 /*
2448  * Tree backend
2449  */
2450
2451 /* Parse output from git-ls-tree(1):
2452  *
2453  * 100644 blob fb0e31ea6cc679b7379631188190e975f5789c26 Makefile
2454  * 100644 blob 5304ca4260aaddaee6498f9630e7d471b8591ea6 README
2455  * 100644 blob f931e1d229c3e185caad4449bf5b66ed72462657 tig.c
2456  * 100644 blob ed09fe897f3c7c9af90bcf80cae92558ea88ae38 web.conf
2457  */
2458
2459 #define SIZEOF_TREE_ATTR \
2460         STRING_SIZE("100644 blob ed09fe897f3c7c9af90bcf80cae92558ea88ae38\t")
2461
2462 #define TREE_UP_FORMAT "040000 tree %s\t.."
2463
2464 static int
2465 tree_compare_entry(enum line_type type1, char *name1,
2466                    enum line_type type2, char *name2)
2467 {
2468         if (type1 != type2) {
2469                 if (type1 == LINE_TREE_DIR)
2470                         return -1;
2471                 return 1;
2472         }
2473
2474         return strcmp(name1, name2);
2475 }
2476
2477 static bool
2478 tree_read(struct view *view, char *text)
2479 {
2480         size_t textlen = strlen(text);
2481         char buf[SIZEOF_STR];
2482         unsigned long pos;
2483         enum line_type type;
2484         bool first_read = view->lines == 0;
2485
2486         if (textlen <= SIZEOF_TREE_ATTR)
2487                 return FALSE;
2488
2489         type = text[STRING_SIZE("100644 ")] == 't'
2490              ? LINE_TREE_DIR : LINE_TREE_FILE;
2491
2492         if (first_read) {
2493                 /* Add path info line */
2494                 if (string_format(buf, "Directory path /%s", opt_path) &&
2495                     realloc_lines(view, view->line_size + 1) &&
2496                     pager_read(view, buf))
2497                         view->line[view->lines - 1].type = LINE_DEFAULT;
2498                 else
2499                         return FALSE;
2500
2501                 /* Insert "link" to parent directory. */
2502                 if (*opt_path &&
2503                     string_format(buf, TREE_UP_FORMAT, view->ref) &&
2504                     realloc_lines(view, view->line_size + 1) &&
2505                     pager_read(view, buf))
2506                         view->line[view->lines - 1].type = LINE_TREE_DIR;
2507                 else if (*opt_path)
2508                         return FALSE;
2509         }
2510
2511         /* Strip the path part ... */
2512         if (*opt_path) {
2513                 size_t pathlen = textlen - SIZEOF_TREE_ATTR;
2514                 size_t striplen = strlen(opt_path);
2515                 char *path = text + SIZEOF_TREE_ATTR;
2516
2517                 if (pathlen > striplen)
2518                         memmove(path, path + striplen,
2519                                 pathlen - striplen + 1);
2520         }
2521
2522         /* Skip "Directory ..." and ".." line. */
2523         for (pos = 1 + !!*opt_path; pos < view->lines; pos++) {
2524                 struct line *line = &view->line[pos];
2525                 char *path1 = ((char *) line->data) + SIZEOF_TREE_ATTR;
2526                 char *path2 = text + SIZEOF_TREE_ATTR;
2527                 int cmp = tree_compare_entry(line->type, path1, type, path2);
2528
2529                 if (cmp <= 0)
2530                         continue;
2531
2532                 text = strdup(text);
2533                 if (!text)
2534                         return FALSE;
2535
2536                 if (view->lines > pos)
2537                         memmove(&view->line[pos + 1], &view->line[pos],
2538                                 (view->lines - pos) * sizeof(*line));
2539
2540                 line = &view->line[pos];
2541                 line->data = text;
2542                 line->type = type;
2543                 view->lines++;
2544                 return TRUE;
2545         }
2546
2547         if (!pager_read(view, text))
2548                 return FALSE;
2549
2550         /* Move the current line to the first tree entry. */
2551         if (first_read)
2552                 view->lineno++;
2553
2554         view->line[view->lines - 1].type = type;
2555         return TRUE;
2556 }
2557
2558 static bool
2559 tree_enter(struct view *view, struct line *line)
2560 {
2561         enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
2562         enum request request;
2563
2564         switch (line->type) {
2565         case LINE_TREE_DIR:
2566                 /* Depending on whether it is a subdir or parent (updir?) link
2567                  * mangle the path buffer. */
2568                 if (line == &view->line[1] && *opt_path) {
2569                         size_t path_len = strlen(opt_path);
2570                         char *dirsep = opt_path + path_len - 1;
2571
2572                         while (dirsep > opt_path && dirsep[-1] != '/')
2573                                 dirsep--;
2574
2575                         dirsep[0] = 0;
2576
2577                 } else {
2578                         size_t pathlen = strlen(opt_path);
2579                         size_t origlen = pathlen;
2580                         char *data = line->data;
2581                         char *basename = data + SIZEOF_TREE_ATTR;
2582
2583                         if (!string_format_from(opt_path, &pathlen, "%s/", basename)) {
2584                                 opt_path[origlen] = 0;
2585                                 return TRUE;
2586                         }
2587                 }
2588
2589                 /* Trees and subtrees share the same ID, so they are not not
2590                  * unique like blobs. */
2591                 flags |= OPEN_RELOAD;
2592                 request = REQ_VIEW_TREE;
2593                 break;
2594
2595         case LINE_TREE_FILE:
2596                 request = REQ_VIEW_BLOB;
2597                 break;
2598
2599         default:
2600                 return TRUE;
2601         }
2602
2603         open_view(view, request, flags);
2604
2605         return TRUE;
2606 }
2607
2608 static void
2609 tree_select(struct view *view, struct line *line)
2610 {
2611         char *text = line->data;
2612
2613         text += STRING_SIZE("100644 blob ");
2614
2615         if (line->type == LINE_TREE_FILE) {
2616                 string_ncopy(ref_blob, text, 40);
2617                 /* Also update the blob view's ref, since all there must always
2618                  * be in sync. */
2619                 string_copy(VIEW(REQ_VIEW_BLOB)->ref, ref_blob);
2620
2621         } else if (line->type != LINE_TREE_DIR) {
2622                 return;
2623         }
2624
2625         string_ncopy(view->ref, text, 40);
2626 }
2627
2628 static struct view_ops tree_ops = {
2629         "file",
2630         pager_draw,
2631         tree_read,
2632         tree_enter,
2633         pager_grep,
2634         tree_select,
2635 };
2636
2637 static bool
2638 blob_read(struct view *view, char *line)
2639 {
2640         bool state = pager_read(view, line);
2641
2642         if (state == TRUE)
2643                 view->line[view->lines - 1].type = LINE_DEFAULT;
2644
2645         return state;
2646 }
2647
2648 static struct view_ops blob_ops = {
2649         "line",
2650         pager_draw,
2651         blob_read,
2652         pager_enter,
2653         pager_grep,
2654         pager_select,
2655 };
2656
2657
2658 /*
2659  * Main view backend
2660  */
2661
2662 struct commit {
2663         char id[SIZEOF_REV];            /* SHA1 ID. */
2664         char title[75];                 /* First line of the commit message. */
2665         char author[75];                /* Author of the commit. */
2666         struct tm time;                 /* Date from the author ident. */
2667         struct ref **refs;              /* Repository references. */
2668         chtype graph[SIZEOF_REVGRAPH];  /* Ancestry chain graphics. */
2669         size_t graph_size;              /* The width of the graph array. */
2670 };
2671
2672 static bool
2673 main_draw(struct view *view, struct line *line, unsigned int lineno, bool selected)
2674 {
2675         char buf[DATE_COLS + 1];
2676         struct commit *commit = line->data;
2677         enum line_type type;
2678         int col = 0;
2679         size_t timelen;
2680         size_t authorlen;
2681         int trimmed = 1;
2682
2683         if (!*commit->author)
2684                 return FALSE;
2685
2686         wmove(view->win, lineno, col);
2687
2688         if (selected) {
2689                 type = LINE_CURSOR;
2690                 wattrset(view->win, get_line_attr(type));
2691                 wchgat(view->win, -1, 0, type, NULL);
2692
2693         } else {
2694                 type = LINE_MAIN_COMMIT;
2695                 wattrset(view->win, get_line_attr(LINE_MAIN_DATE));
2696         }
2697
2698         timelen = strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time);
2699         waddnstr(view->win, buf, timelen);
2700         waddstr(view->win, " ");
2701
2702         col += DATE_COLS;
2703         wmove(view->win, lineno, col);
2704         if (type != LINE_CURSOR)
2705                 wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
2706
2707         if (opt_utf8) {
2708                 authorlen = utf8_length(commit->author, AUTHOR_COLS - 2, &col, &trimmed);
2709         } else {
2710                 authorlen = strlen(commit->author);
2711                 if (authorlen > AUTHOR_COLS - 2) {
2712                         authorlen = AUTHOR_COLS - 2;
2713                         trimmed = 1;
2714                 }
2715         }
2716
2717         if (trimmed) {
2718                 waddnstr(view->win, commit->author, authorlen);
2719                 if (type != LINE_CURSOR)
2720                         wattrset(view->win, get_line_attr(LINE_MAIN_DELIM));
2721                 waddch(view->win, '~');
2722         } else {
2723                 waddstr(view->win, commit->author);
2724         }
2725
2726         col += AUTHOR_COLS;
2727         if (type != LINE_CURSOR)
2728                 wattrset(view->win, A_NORMAL);
2729
2730         if (opt_rev_graph && commit->graph_size) {
2731                 size_t i;
2732
2733                 wmove(view->win, lineno, col);
2734                 /* Using waddch() instead of waddnstr() ensures that
2735                  * they'll be rendered correctly for the cursor line. */
2736                 for (i = 0; i < commit->graph_size; i++)
2737                         waddch(view->win, commit->graph[i]);
2738
2739                 col += commit->graph_size + 1;
2740         }
2741
2742         wmove(view->win, lineno, col);
2743
2744         if (commit->refs) {
2745                 size_t i = 0;
2746
2747                 do {
2748                         if (type == LINE_CURSOR)
2749                                 ;
2750                         else if (commit->refs[i]->tag)
2751                                 wattrset(view->win, get_line_attr(LINE_MAIN_TAG));
2752                         else
2753                                 wattrset(view->win, get_line_attr(LINE_MAIN_REF));
2754                         waddstr(view->win, "[");
2755                         waddstr(view->win, commit->refs[i]->name);
2756                         waddstr(view->win, "]");
2757                         if (type != LINE_CURSOR)
2758                                 wattrset(view->win, A_NORMAL);
2759                         waddstr(view->win, " ");
2760                         col += strlen(commit->refs[i]->name) + STRING_SIZE("[] ");
2761                 } while (commit->refs[i++]->next);
2762         }
2763
2764         if (type != LINE_CURSOR)
2765                 wattrset(view->win, get_line_attr(type));
2766
2767         {
2768                 int titlelen = strlen(commit->title);
2769
2770                 if (col + titlelen > view->width)
2771                         titlelen = view->width - col;
2772
2773                 waddnstr(view->win, commit->title, titlelen);
2774         }
2775
2776         return TRUE;
2777 }
2778
2779 /* Reads git log --pretty=raw output and parses it into the commit struct. */
2780 static bool
2781 main_read(struct view *view, char *line)
2782 {
2783         enum line_type type = get_line_type(line);
2784         struct commit *commit = view->lines
2785                               ? view->line[view->lines - 1].data : NULL;
2786
2787         switch (type) {
2788         case LINE_COMMIT:
2789                 commit = calloc(1, sizeof(struct commit));
2790                 if (!commit)
2791                         return FALSE;
2792
2793                 line += STRING_SIZE("commit ");
2794
2795                 view->line[view->lines++].data = commit;
2796                 string_copy(commit->id, line);
2797                 commit->refs = get_refs(commit->id);
2798                 commit->graph[commit->graph_size++] = ACS_LTEE;
2799                 break;
2800
2801         case LINE_AUTHOR:
2802         {
2803                 char *ident = line + STRING_SIZE("author ");
2804                 char *end = strchr(ident, '<');
2805
2806                 if (!commit)
2807                         break;
2808
2809                 if (end) {
2810                         char *email = end + 1;
2811
2812                         for (; end > ident && isspace(end[-1]); end--) ;
2813
2814                         if (end == ident && *email) {
2815                                 ident = email;
2816                                 end = strchr(ident, '>');
2817                                 for (; end > ident && isspace(end[-1]); end--) ;
2818                         }
2819                         *end = 0;
2820                 }
2821
2822                 /* End is NULL or ident meaning there's no author. */
2823                 if (end <= ident)
2824                         ident = "Unknown";
2825
2826                 string_copy(commit->author, ident);
2827
2828                 /* Parse epoch and timezone */
2829                 if (end) {
2830                         char *secs = strchr(end + 1, '>');
2831                         char *zone;
2832                         time_t time;
2833
2834                         if (!secs || secs[1] != ' ')
2835                                 break;
2836
2837                         secs += 2;
2838                         time = (time_t) atol(secs);
2839                         zone = strchr(secs, ' ');
2840                         if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
2841                                 long tz;
2842
2843                                 zone++;
2844                                 tz  = ('0' - zone[1]) * 60 * 60 * 10;
2845                                 tz += ('0' - zone[2]) * 60 * 60;
2846                                 tz += ('0' - zone[3]) * 60;
2847                                 tz += ('0' - zone[4]) * 60;
2848
2849                                 if (zone[0] == '-')
2850                                         tz = -tz;
2851
2852                                 time -= tz;
2853                         }
2854                         gmtime_r(&time, &commit->time);
2855                 }
2856                 break;
2857         }
2858         default:
2859                 if (!commit)
2860                         break;
2861
2862                 /* Fill in the commit title if it has not already been set. */
2863                 if (commit->title[0])
2864                         break;
2865
2866                 /* Require titles to start with a non-space character at the
2867                  * offset used by git log. */
2868                 /* FIXME: More gracefull handling of titles; append "..." to
2869                  * shortened titles, etc. */
2870                 if (strncmp(line, "    ", 4) ||
2871                     isspace(line[4]))
2872                         break;
2873
2874                 string_copy(commit->title, line + 4);
2875         }
2876
2877         return TRUE;
2878 }
2879
2880 static bool
2881 main_enter(struct view *view, struct line *line)
2882 {
2883         enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
2884
2885         open_view(view, REQ_VIEW_DIFF, flags);
2886         return TRUE;
2887 }
2888
2889 static bool
2890 main_grep(struct view *view, struct line *line)
2891 {
2892         struct commit *commit = line->data;
2893         enum { S_TITLE, S_AUTHOR, S_DATE, S_END } state;
2894         char buf[DATE_COLS + 1];
2895         regmatch_t pmatch;
2896
2897         for (state = S_TITLE; state < S_END; state++) {
2898                 char *text;
2899
2900                 switch (state) {
2901                 case S_TITLE:   text = commit->title;   break;
2902                 case S_AUTHOR:  text = commit->author;  break;
2903                 case S_DATE:
2904                         if (!strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time))
2905                                 continue;
2906                         text = buf;
2907                         break;
2908
2909                 default:
2910                         return FALSE;
2911                 }
2912
2913                 if (regexec(view->regex, text, 1, &pmatch, 0) != REG_NOMATCH)
2914                         return TRUE;
2915         }
2916
2917         return FALSE;
2918 }
2919
2920 static void
2921 main_select(struct view *view, struct line *line)
2922 {
2923         struct commit *commit = line->data;
2924
2925         string_copy(view->ref, commit->id);
2926         string_copy(ref_commit, view->ref);
2927 }
2928
2929 static struct view_ops main_ops = {
2930         "commit",
2931         main_draw,
2932         main_read,
2933         main_enter,
2934         main_grep,
2935         main_select,
2936 };
2937
2938
2939 /*
2940  * Unicode / UTF-8 handling
2941  *
2942  * NOTE: Much of the following code for dealing with unicode is derived from
2943  * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
2944  * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
2945  */
2946
2947 /* I've (over)annotated a lot of code snippets because I am not entirely
2948  * confident that the approach taken by this small UTF-8 interface is correct.
2949  * --jonas */
2950
2951 static inline int
2952 unicode_width(unsigned long c)
2953 {
2954         if (c >= 0x1100 &&
2955            (c <= 0x115f                         /* Hangul Jamo */
2956             || c == 0x2329
2957             || c == 0x232a
2958             || (c >= 0x2e80  && c <= 0xa4cf && c != 0x303f)
2959                                                 /* CJK ... Yi */
2960             || (c >= 0xac00  && c <= 0xd7a3)    /* Hangul Syllables */
2961             || (c >= 0xf900  && c <= 0xfaff)    /* CJK Compatibility Ideographs */
2962             || (c >= 0xfe30  && c <= 0xfe6f)    /* CJK Compatibility Forms */
2963             || (c >= 0xff00  && c <= 0xff60)    /* Fullwidth Forms */
2964             || (c >= 0xffe0  && c <= 0xffe6)
2965             || (c >= 0x20000 && c <= 0x2fffd)
2966             || (c >= 0x30000 && c <= 0x3fffd)))
2967                 return 2;
2968
2969         return 1;
2970 }
2971
2972 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
2973  * Illegal bytes are set one. */
2974 static const unsigned char utf8_bytes[256] = {
2975         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,
2976         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,
2977         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,
2978         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,
2979         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,
2980         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,
2981         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,
2982         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,
2983 };
2984
2985 /* Decode UTF-8 multi-byte representation into a unicode character. */
2986 static inline unsigned long
2987 utf8_to_unicode(const char *string, size_t length)
2988 {
2989         unsigned long unicode;
2990
2991         switch (length) {
2992         case 1:
2993                 unicode  =   string[0];
2994                 break;
2995         case 2:
2996                 unicode  =  (string[0] & 0x1f) << 6;
2997                 unicode +=  (string[1] & 0x3f);
2998                 break;
2999         case 3:
3000                 unicode  =  (string[0] & 0x0f) << 12;
3001                 unicode += ((string[1] & 0x3f) << 6);
3002                 unicode +=  (string[2] & 0x3f);
3003                 break;
3004         case 4:
3005                 unicode  =  (string[0] & 0x0f) << 18;
3006                 unicode += ((string[1] & 0x3f) << 12);
3007                 unicode += ((string[2] & 0x3f) << 6);
3008                 unicode +=  (string[3] & 0x3f);
3009                 break;
3010         case 5:
3011                 unicode  =  (string[0] & 0x0f) << 24;
3012                 unicode += ((string[1] & 0x3f) << 18);
3013                 unicode += ((string[2] & 0x3f) << 12);
3014                 unicode += ((string[3] & 0x3f) << 6);
3015                 unicode +=  (string[4] & 0x3f);
3016                 break;
3017         case 6:
3018                 unicode  =  (string[0] & 0x01) << 30;
3019                 unicode += ((string[1] & 0x3f) << 24);
3020                 unicode += ((string[2] & 0x3f) << 18);
3021                 unicode += ((string[3] & 0x3f) << 12);
3022                 unicode += ((string[4] & 0x3f) << 6);
3023                 unicode +=  (string[5] & 0x3f);
3024                 break;
3025         default:
3026                 die("Invalid unicode length");
3027         }
3028
3029         /* Invalid characters could return the special 0xfffd value but NUL
3030          * should be just as good. */
3031         return unicode > 0xffff ? 0 : unicode;
3032 }
3033
3034 /* Calculates how much of string can be shown within the given maximum width
3035  * and sets trimmed parameter to non-zero value if all of string could not be
3036  * shown.
3037  *
3038  * Additionally, adds to coloffset how many many columns to move to align with
3039  * the expected position. Takes into account how multi-byte and double-width
3040  * characters will effect the cursor position.
3041  *
3042  * Returns the number of bytes to output from string to satisfy max_width. */
3043 static size_t
3044 utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed)
3045 {
3046         const char *start = string;
3047         const char *end = strchr(string, '\0');
3048         size_t mbwidth = 0;
3049         size_t width = 0;
3050
3051         *trimmed = 0;
3052
3053         while (string < end) {
3054                 int c = *(unsigned char *) string;
3055                 unsigned char bytes = utf8_bytes[c];
3056                 size_t ucwidth;
3057                 unsigned long unicode;
3058
3059                 if (string + bytes > end)
3060                         break;
3061
3062                 /* Change representation to figure out whether
3063                  * it is a single- or double-width character. */
3064
3065                 unicode = utf8_to_unicode(string, bytes);
3066                 /* FIXME: Graceful handling of invalid unicode character. */
3067                 if (!unicode)
3068                         break;
3069
3070                 ucwidth = unicode_width(unicode);
3071                 width  += ucwidth;
3072                 if (width > max_width) {
3073                         *trimmed = 1;
3074                         break;
3075                 }
3076
3077                 /* The column offset collects the differences between the
3078                  * number of bytes encoding a character and the number of
3079                  * columns will be used for rendering said character.
3080                  *
3081                  * So if some character A is encoded in 2 bytes, but will be
3082                  * represented on the screen using only 1 byte this will and up
3083                  * adding 1 to the multi-byte column offset.
3084                  *
3085                  * Assumes that no double-width character can be encoding in
3086                  * less than two bytes. */
3087                 if (bytes > ucwidth)
3088                         mbwidth += bytes - ucwidth;
3089
3090                 string  += bytes;
3091         }
3092
3093         *coloffset += mbwidth;
3094
3095         return string - start;
3096 }
3097
3098
3099 /*
3100  * Status management
3101  */
3102
3103 /* Whether or not the curses interface has been initialized. */
3104 static bool cursed = FALSE;
3105
3106 /* The status window is used for polling keystrokes. */
3107 static WINDOW *status_win;
3108
3109 /* Update status and title window. */
3110 static void
3111 report(const char *msg, ...)
3112 {
3113         static bool empty = TRUE;
3114         struct view *view = display[current_view];
3115
3116         if (!empty || *msg) {
3117                 va_list args;
3118
3119                 va_start(args, msg);
3120
3121                 werase(status_win);
3122                 wmove(status_win, 0, 0);
3123                 if (*msg) {
3124                         vwprintw(status_win, msg, args);
3125                         empty = FALSE;
3126                 } else {
3127                         empty = TRUE;
3128                 }
3129                 wrefresh(status_win);
3130
3131                 va_end(args);
3132         }
3133
3134         update_view_title(view);
3135         update_display_cursor();
3136 }
3137
3138 /* Controls when nodelay should be in effect when polling user input. */
3139 static void
3140 set_nonblocking_input(bool loading)
3141 {
3142         static unsigned int loading_views;
3143
3144         if ((loading == FALSE && loading_views-- == 1) ||
3145             (loading == TRUE  && loading_views++ == 0))
3146                 nodelay(status_win, loading);
3147 }
3148
3149 static void
3150 init_display(void)
3151 {
3152         int x, y;
3153
3154         /* Initialize the curses library */
3155         if (isatty(STDIN_FILENO)) {
3156                 cursed = !!initscr();
3157         } else {
3158                 /* Leave stdin and stdout alone when acting as a pager. */
3159                 FILE *io = fopen("/dev/tty", "r+");
3160
3161                 if (!io)
3162                         die("Failed to open /dev/tty");
3163                 cursed = !!newterm(NULL, io, io);
3164         }
3165
3166         if (!cursed)
3167                 die("Failed to initialize curses");
3168
3169         nonl();         /* Tell curses not to do NL->CR/NL on output */
3170         cbreak();       /* Take input chars one at a time, no wait for \n */
3171         noecho();       /* Don't echo input */
3172         leaveok(stdscr, TRUE);
3173
3174         if (has_colors())
3175                 init_colors();
3176
3177         getmaxyx(stdscr, y, x);
3178         status_win = newwin(1, 0, y - 1, 0);
3179         if (!status_win)
3180                 die("Failed to create status window");
3181
3182         /* Enable keyboard mapping */
3183         keypad(status_win, TRUE);
3184         wbkgdset(status_win, get_line_attr(LINE_STATUS));
3185 }
3186
3187 static char *
3188 read_prompt(const char *prompt)
3189 {
3190         enum { READING, STOP, CANCEL } status = READING;
3191         static char buf[sizeof(opt_cmd) - STRING_SIZE("git \0")];
3192         int pos = 0;
3193
3194         while (status == READING) {
3195                 struct view *view;
3196                 int i, key;
3197
3198                 foreach_view (view, i)
3199                         update_view(view);
3200
3201                 report("%s%.*s", prompt, pos, buf);
3202                 /* Refresh, accept single keystroke of input */
3203                 key = wgetch(status_win);
3204                 switch (key) {
3205                 case KEY_RETURN:
3206                 case KEY_ENTER:
3207                 case '\n':
3208                         status = pos ? STOP : CANCEL;
3209                         break;
3210
3211                 case KEY_BACKSPACE:
3212                         if (pos > 0)
3213                                 pos--;
3214                         else
3215                                 status = CANCEL;
3216                         break;
3217
3218                 case KEY_ESC:
3219                         status = CANCEL;
3220                         break;
3221
3222                 case ERR:
3223                         break;
3224
3225                 default:
3226                         if (pos >= sizeof(buf)) {
3227                                 report("Input string too long");
3228                                 return NULL;
3229                         }
3230
3231                         if (isprint(key))
3232                                 buf[pos++] = (char) key;
3233                 }
3234         }
3235
3236         if (status == CANCEL) {
3237                 /* Clear the status window */
3238                 report("");
3239                 return NULL;
3240         }
3241
3242         buf[pos++] = 0;
3243
3244         return buf;
3245 }
3246
3247 /*
3248  * Repository references
3249  */
3250
3251 static struct ref *refs;
3252 static size_t refs_size;
3253
3254 /* Id <-> ref store */
3255 static struct ref ***id_refs;
3256 static size_t id_refs_size;
3257
3258 static struct ref **
3259 get_refs(char *id)
3260 {
3261         struct ref ***tmp_id_refs;
3262         struct ref **ref_list = NULL;
3263         size_t ref_list_size = 0;
3264         size_t i;
3265
3266         for (i = 0; i < id_refs_size; i++)
3267                 if (!strcmp(id, id_refs[i][0]->id))
3268                         return id_refs[i];
3269
3270         tmp_id_refs = realloc(id_refs, (id_refs_size + 1) * sizeof(*id_refs));
3271         if (!tmp_id_refs)
3272                 return NULL;
3273
3274         id_refs = tmp_id_refs;
3275
3276         for (i = 0; i < refs_size; i++) {
3277                 struct ref **tmp;
3278
3279                 if (strcmp(id, refs[i].id))
3280                         continue;
3281
3282                 tmp = realloc(ref_list, (ref_list_size + 1) * sizeof(*ref_list));
3283                 if (!tmp) {
3284                         if (ref_list)
3285                                 free(ref_list);
3286                         return NULL;
3287                 }
3288
3289                 ref_list = tmp;
3290                 if (ref_list_size > 0)
3291                         ref_list[ref_list_size - 1]->next = 1;
3292                 ref_list[ref_list_size] = &refs[i];
3293
3294                 /* XXX: The properties of the commit chains ensures that we can
3295                  * safely modify the shared ref. The repo references will
3296                  * always be similar for the same id. */
3297                 ref_list[ref_list_size]->next = 0;
3298                 ref_list_size++;
3299         }
3300
3301         if (ref_list)
3302                 id_refs[id_refs_size++] = ref_list;
3303
3304         return ref_list;
3305 }
3306
3307 static int
3308 read_ref(char *id, int idlen, char *name, int namelen)
3309 {
3310         struct ref *ref;
3311         bool tag = FALSE;
3312
3313         if (!strncmp(name, "refs/tags/", STRING_SIZE("refs/tags/"))) {
3314                 /* Commits referenced by tags has "^{}" appended. */
3315                 if (name[namelen - 1] != '}')
3316                         return OK;
3317
3318                 while (namelen > 0 && name[namelen] != '^')
3319                         namelen--;
3320
3321                 tag = TRUE;
3322                 namelen -= STRING_SIZE("refs/tags/");
3323                 name    += STRING_SIZE("refs/tags/");
3324
3325         } else if (!strncmp(name, "refs/heads/", STRING_SIZE("refs/heads/"))) {
3326                 namelen -= STRING_SIZE("refs/heads/");
3327                 name    += STRING_SIZE("refs/heads/");
3328
3329         } else if (!strcmp(name, "HEAD")) {
3330                 return OK;
3331         }
3332
3333         refs = realloc(refs, sizeof(*refs) * (refs_size + 1));
3334         if (!refs)
3335                 return ERR;
3336
3337         ref = &refs[refs_size++];
3338         ref->name = malloc(namelen + 1);
3339         if (!ref->name)
3340                 return ERR;
3341
3342         strncpy(ref->name, name, namelen);
3343         ref->name[namelen] = 0;
3344         ref->tag = tag;
3345         string_copy(ref->id, id);
3346
3347         return OK;
3348 }
3349
3350 static int
3351 load_refs(void)
3352 {
3353         const char *cmd_env = getenv("TIG_LS_REMOTE");
3354         const char *cmd = cmd_env && *cmd_env ? cmd_env : TIG_LS_REMOTE;
3355
3356         return read_properties(popen(cmd, "r"), "\t", read_ref);
3357 }
3358
3359 static int
3360 read_repo_config_option(char *name, int namelen, char *value, int valuelen)
3361 {
3362         if (!strcmp(name, "i18n.commitencoding"))
3363                 string_copy(opt_encoding, value);
3364
3365         return OK;
3366 }
3367
3368 static int
3369 load_repo_config(void)
3370 {
3371         return read_properties(popen("git repo-config --list", "r"),
3372                                "=", read_repo_config_option);
3373 }
3374
3375 static int
3376 read_properties(FILE *pipe, const char *separators,
3377                 int (*read_property)(char *, int, char *, int))
3378 {
3379         char buffer[BUFSIZ];
3380         char *name;
3381         int state = OK;
3382
3383         if (!pipe)
3384                 return ERR;
3385
3386         while (state == OK && (name = fgets(buffer, sizeof(buffer), pipe))) {
3387                 char *value;
3388                 size_t namelen;
3389                 size_t valuelen;
3390
3391                 name = chomp_string(name);
3392                 namelen = strcspn(name, separators);
3393
3394                 if (name[namelen]) {
3395                         name[namelen] = 0;
3396                         value = chomp_string(name + namelen + 1);
3397                         valuelen = strlen(value);
3398
3399                 } else {
3400                         value = "";
3401                         valuelen = 0;
3402                 }
3403
3404                 state = read_property(name, namelen, value, valuelen);
3405         }
3406
3407         if (state != ERR && ferror(pipe))
3408                 state = ERR;
3409
3410         pclose(pipe);
3411
3412         return state;
3413 }
3414
3415
3416 /*
3417  * Main
3418  */
3419
3420 static void __NORETURN
3421 quit(int sig)
3422 {
3423         /* XXX: Restore tty modes and let the OS cleanup the rest! */
3424         if (cursed)
3425                 endwin();
3426         exit(0);
3427 }
3428
3429 static void __NORETURN
3430 die(const char *err, ...)
3431 {
3432         va_list args;
3433
3434         endwin();
3435
3436         va_start(args, err);
3437         fputs("tig: ", stderr);
3438         vfprintf(stderr, err, args);
3439         fputs("\n", stderr);
3440         va_end(args);
3441
3442         exit(1);
3443 }
3444
3445 int
3446 main(int argc, char *argv[])
3447 {
3448         struct view *view;
3449         enum request request;
3450         size_t i;
3451
3452         signal(SIGINT, quit);
3453
3454         if (setlocale(LC_ALL, "")) {
3455                 string_copy(opt_codeset, nl_langinfo(CODESET));
3456         }
3457
3458         if (load_options() == ERR)
3459                 die("Failed to load user config.");
3460
3461         /* Load the repo config file so options can be overwritten from
3462          * the command line.  */
3463         if (load_repo_config() == ERR)
3464                 die("Failed to load repo config.");
3465
3466         if (!parse_options(argc, argv))
3467                 return 0;
3468
3469         if (*opt_codeset && strcmp(opt_codeset, opt_encoding)) {
3470                 opt_iconv = iconv_open(opt_codeset, opt_encoding);
3471                 if (opt_iconv == ICONV_NONE)
3472                         die("Failed to initialize character set conversion");
3473         }
3474
3475         if (load_refs() == ERR)
3476                 die("Failed to load refs.");
3477
3478         /* Require a git repository unless when running in pager mode. */
3479         if (refs_size == 0 && opt_request != REQ_VIEW_PAGER)
3480                 die("Not a git repository");
3481
3482         for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
3483                 view->cmd_env = getenv(view->cmd_env);
3484
3485         request = opt_request;
3486
3487         init_display();
3488
3489         while (view_driver(display[current_view], request)) {
3490                 int key;
3491                 int i;
3492
3493                 foreach_view (view, i)
3494                         update_view(view);
3495
3496                 /* Refresh, accept single keystroke of input */
3497                 key = wgetch(status_win);
3498
3499                 request = get_keybinding(display[current_view]->keymap, key);
3500
3501                 /* Some low-level request handling. This keeps access to
3502                  * status_win restricted. */
3503                 switch (request) {
3504                 case REQ_PROMPT:
3505                 {
3506                         char *cmd = read_prompt(":");
3507
3508                         if (cmd && string_format(opt_cmd, "git %s", cmd)) {
3509                                 if (strncmp(cmd, "show", 4) && isspace(cmd[4])) {
3510                                         opt_request = REQ_VIEW_DIFF;
3511                                 } else {
3512                                         opt_request = REQ_VIEW_PAGER;
3513                                 }
3514                                 break;
3515                         }
3516
3517                         request = REQ_NONE;
3518                         break;
3519                 }
3520                 case REQ_SEARCH:
3521                 case REQ_SEARCH_BACK:
3522                 {
3523                         const char *prompt = request == REQ_SEARCH
3524                                            ? "/" : "?";
3525                         char *search = read_prompt(prompt);
3526
3527                         if (search)
3528                                 string_copy(opt_search, search);
3529                         else
3530                                 request = REQ_NONE;
3531                         break;
3532                 }
3533                 case REQ_SCREEN_RESIZE:
3534                 {
3535                         int height, width;
3536
3537                         getmaxyx(stdscr, height, width);
3538
3539                         /* Resize the status view and let the view driver take
3540                          * care of resizing the displayed views. */
3541                         wresize(status_win, 1, width);
3542                         mvwin(status_win, height - 1, 0);
3543                         wrefresh(status_win);
3544                         break;
3545                 }
3546                 default:
3547                         break;
3548                 }
3549         }
3550
3551         quit(0);
3552
3553         return 0;
3554 }