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

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