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

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