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