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

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