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.3"
  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 <curses.h>
  34
  35 #if __GNUC__ >= 3
  36 #define __NORETURN __attribute__((__noreturn__))
  37 #else
  38 #define __NORETURN
  39 #endif
  40
  41 static void __NORETURN die(const char *err, ...);
  42 static void report(const char *msg, ...);
  43 static int read_properties(FILE *pipe, const char *separators, int (*read)(char *, int, char *, int));
  44 static void set_nonblocking_input(bool loading);
  45 static size_t utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed);
  46
  47 #define ABS(x)          ((x) >= 0  ? (x) : -(x))
  48 #define MIN(x, y)       ((x) < (y) ? (x) :  (y))
  49
  50 #define ARRAY_SIZE(x)   (sizeof(x) / sizeof(x[0]))
  51 #define STRING_SIZE(x)  (sizeof(x) - 1)
  52
  53 #define SIZEOF_REF      256     /* Size of symbolic or SHA1 ID. */
  54 #define SIZEOF_CMD      1024    /* Size of command buffer. */
  55 #define SIZEOF_REVGRAPH 19      /* Size of revision ancestry graphics. */
  56
  57 /* This color name can be used to refer to the default term colors. */
  58 #define COLOR_DEFAULT   (-1)
  59
  60 /* The format and size of the date column in the main view. */
  61 #define DATE_FORMAT     "%Y-%m-%d %H:%M"
  62 #define DATE_COLS       STRING_SIZE("2006-04-29 14:21 ")
  63
  64 #define AUTHOR_COLS     20
  65
  66 /* The default interval between line numbers. */
  67 #define NUMBER_INTERVAL 1
  68
  69 #define TABSIZE         8
  70
  71 #define SCALE_SPLIT_VIEW(height)        ((height) * 2 / 3)
  72
  73 #define TIG_LS_REMOTE \
  74         "git ls-remote . 2>/dev/null"
  75
  76 #define TIG_DIFF_CMD \
  77         "git show --patch-with-stat --find-copies-harder -B -C %s"
  78
  79 #define TIG_LOG_CMD     \
  80         "git log --cc --stat -n100 %s"
  81
  82 #define TIG_MAIN_CMD \
  83         "git log --topo-order --stat --pretty=raw %s"
  84
  85 /* XXX: Needs to be defined to the empty string. */
  86 #define TIG_HELP_CMD    ""
  87 #define TIG_PAGER_CMD   ""
  88
  89 /* Some ascii-shorthands fitted into the ncurses namespace. */
  90 #define KEY_TAB         '\t'
  91 #define KEY_RETURN      '\r'
  92 #define KEY_ESC         27
  93
  94
  95 struct ref {
  96         char *name;             /* Ref name; tag or head names are shortened. */
  97         char id[41];            /* Commit SHA1 ID */
  98         unsigned int tag:1;     /* Is it a tag? */
  99         unsigned int next:1;    /* For ref lists: are there more refs? */
 100 };
 101
 102 static struct ref **get_refs(char *id);
 103
 104 struct int_map {
 105         const char *name;
 106         int namelen;
 107         int value;
 108 };
 109
 110 static int
 111 set_from_int_map(struct int_map *map, size_t map_size,
 112                  int *value, const char *name, int namelen)
 113 {
 114
 115         int i;
 116
 117         for (i = 0; i < map_size; i++)
 118                 if (namelen == map[i].namelen &&
 119                     !strncasecmp(name, map[i].name, namelen)) {
 120                         *value = map[i].value;
 121                         return OK;
 122                 }
 123
 124         return ERR;
 125 }
 126
 127
 128 /*
 129  * String helpers
 130  */
 131
 132 static inline void
 133 string_ncopy(char *dst, const char *src, int dstlen)
 134 {
 135         strncpy(dst, src, dstlen - 1);
 136         dst[dstlen - 1] = 0;
 137
 138 }
 139
 140 /* Shorthand for safely copying into a fixed buffer. */
 141 #define string_copy(dst, src) \
 142         string_ncopy(dst, src, sizeof(dst))
 143
 144 static char *
 145 chomp_string(char *name)
 146 {
 147         int namelen;
 148
 149         while (isspace(*name))
 150                 name++;
 151
 152         namelen = strlen(name) - 1;
 153         while (namelen > 0 && isspace(name[namelen]))
 154                 name[namelen--] = 0;
 155
 156         return name;
 157 }
 158
 159 static bool
 160 string_nformat(char *buf, size_t bufsize, int *bufpos, const char *fmt, ...)
 161 {
 162         va_list args;
 163         int pos = bufpos ? *bufpos : 0;
 164
 165         va_start(args, fmt);
 166         pos += vsnprintf(buf + pos, bufsize - pos, fmt, args);
 167         va_end(args);
 168
 169         if (bufpos)
 170                 *bufpos = pos;
 171
 172         return pos >= bufsize ? FALSE : TRUE;
 173 }
 174
 175 #define string_format(buf, fmt, args...) \
 176         string_nformat(buf, sizeof(buf), NULL, fmt, args)
 177
 178 #define string_format_from(buf, from, fmt, args...) \
 179         string_nformat(buf, sizeof(buf), from, fmt, args)
 180
 181 static int
 182 string_enum_compare(const char *str1, const char *str2, int len)
 183 {
 184         size_t i;
 185
 186 #define string_enum_sep(x) ((x) == '-' || (x) == '_' || (x) == '.')
 187
 188         /* Diff-Header == DIFF_HEADER */
 189         for (i = 0; i < len; i++) {
 190                 if (toupper(str1[i]) == toupper(str2[i]))
 191                         continue;
 192
 193                 if (string_enum_sep(str1[i]) &&
 194                     string_enum_sep(str2[i]))
 195                         continue;
 196
 197                 return str1[i] - str2[i];
 198         }
 199
 200         return 0;
 201 }
 202
 203 /* Shell quoting
 204  *
 205  * NOTE: The following is a slightly modified copy of the git project's shell
 206  * quoting routines found in the quote.c file.
 207  *
 208  * Help to copy the thing properly quoted for the shell safety.  any single
 209  * quote is replaced with '\'', any exclamation point is replaced with '\!',
 210  * and the whole thing is enclosed in a
 211  *
 212  * E.g.
 213  *  original     sq_quote     result
 214  *  name     ==> name      ==> 'name'
 215  *  a b      ==> a b       ==> 'a b'
 216  *  a'b      ==> a'\''b    ==> 'a'\''b'
 217  *  a!b      ==> a'\!'b    ==> 'a'\!'b'
 218  */
 219
 220 static size_t
 221 sq_quote(char buf[SIZEOF_CMD], size_t bufsize, const char *src)
 222 {
 223         char c;
 224
 225 #define BUFPUT(x) do { if (bufsize < SIZEOF_CMD) buf[bufsize++] = (x); } while (0)
 226
 227         BUFPUT('\'');
 228         while ((c = *src++)) {
 229                 if (c == '\'' || c == '!') {
 230                         BUFPUT('\'');
 231                         BUFPUT('\\');
 232                         BUFPUT(c);
 233                         BUFPUT('\'');
 234                 } else {
 235                         BUFPUT(c);
 236                 }
 237         }
 238         BUFPUT('\'');
 239
 240         return bufsize;
 241 }
 242
 243
 244 /*
 245  * User requests
 246  */
 247
 248 #define REQ_INFO \
 249         /* XXX: Keep the view request first and in sync with views[]. */ \
 250         REQ_GROUP("View switching") \
 251         REQ_(VIEW_MAIN,         "Show main view"), \
 252         REQ_(VIEW_DIFF,         "Show diff view"), \
 253         REQ_(VIEW_LOG,          "Show log view"), \
 254         REQ_(VIEW_HELP,         "Show help page"), \
 255         REQ_(VIEW_PAGER,        "Show pager view"), \
 256         \
 257         REQ_GROUP("View manipulation") \
 258         REQ_(ENTER,             "Enter current line and scroll"), \
 259         REQ_(NEXT,              "Move to next"), \
 260         REQ_(PREVIOUS,          "Move to previous"), \
 261         REQ_(VIEW_NEXT,         "Move focus to next view"), \
 262         REQ_(VIEW_CLOSE,        "Close the current view"), \
 263         REQ_(QUIT,              "Close all views and quit"), \
 264         \
 265         REQ_GROUP("Cursor navigation") \
 266         REQ_(MOVE_UP,           "Move cursor one line up"), \
 267         REQ_(MOVE_DOWN,         "Move cursor one line down"), \
 268         REQ_(MOVE_PAGE_DOWN,    "Move cursor one page down"), \
 269         REQ_(MOVE_PAGE_UP,      "Move cursor one page up"), \
 270         REQ_(MOVE_FIRST_LINE,   "Move cursor to first line"), \
 271         REQ_(MOVE_LAST_LINE,    "Move cursor to last line"), \
 272         \
 273         REQ_GROUP("Scrolling") \
 274         REQ_(SCROLL_LINE_UP,    "Scroll one line up"), \
 275         REQ_(SCROLL_LINE_DOWN,  "Scroll one line down"), \
 276         REQ_(SCROLL_PAGE_UP,    "Scroll one page up"), \
 277         REQ_(SCROLL_PAGE_DOWN,  "Scroll one page down"), \
 278         \
 279         REQ_GROUP("Misc") \
 280         REQ_(PROMPT,            "Bring up the prompt"), \
 281         REQ_(SCREEN_UPDATE,     "Update the screen"), \
 282         REQ_(SCREEN_REDRAW,     "Redraw the screen"), \
 283         REQ_(SCREEN_RESIZE,     "Resize the screen"), \
 284         REQ_(SHOW_VERSION,      "Show version information"), \
 285         REQ_(STOP_LOADING,      "Stop all loading views"), \
 286         REQ_(TOGGLE_LINENO,     "Toggle line numbers"), \
 287         REQ_(TOGGLE_REV_GRAPH,  "Toggle revision graph visualization"),
 288
 289
 290 /* User action requests. */
 291 enum request {
 292 #define REQ_GROUP(help)
 293 #define REQ_(req, help) REQ_##req
 294
 295         /* Offset all requests to avoid conflicts with ncurses getch values. */
 296         REQ_OFFSET = KEY_MAX + 1,
 297         REQ_INFO
 298
 299 #undef  REQ_GROUP
 300 #undef  REQ_
 301 };
 302
 303 struct request_info {
 304         enum request request;
 305         char *help;
 306 };
 307
 308 static struct request_info req_info[] = {
 309 #define REQ_GROUP(help) { 0, (help) },
 310 #define REQ_(req, help) { REQ_##req, (help) }
 311         REQ_INFO
 312 #undef  REQ_GROUP
 313 #undef  REQ_
 314 };
 315
 316 /*
 317  * Options
 318  */
 319
 320 static const char usage[] =
 321 VERSION " (" __DATE__ ")\n"
 322 "\n"
 323 "Usage: tig [options]\n"
 324 "   or: tig [options] [--] [git log options]\n"
 325 "   or: tig [options] log  [git log options]\n"
 326 "   or: tig [options] diff [git diff options]\n"
 327 "   or: tig [options] show [git show options]\n"
 328 "   or: tig [options] <    [git command output]\n"
 329 "\n"
 330 "Options:\n"
 331 "  -l                          Start up in log view\n"
 332 "  -d                          Start up in diff view\n"
 333 "  -n[I], --line-number[=I]    Show line numbers with given interval\n"
 334 "  -b[N], --tab-size[=N]       Set number of spaces for tab expansion\n"
 335 "  --                          Mark end of tig options\n"
 336 "  -v, --version               Show version and exit\n"
 337 "  -h, --help                  Show help message and exit\n";
 338
 339 /* Option and state variables. */
 340 static bool opt_line_number     = FALSE;
 341 static bool opt_rev_graph       = TRUE;
 342 static int opt_num_interval     = NUMBER_INTERVAL;
 343 static int opt_tab_size         = TABSIZE;
 344 static enum request opt_request = REQ_VIEW_MAIN;
 345 static char opt_cmd[SIZEOF_CMD] = "";
 346 static char opt_encoding[20]    = "";
 347 static bool opt_utf8            = TRUE;
 348 static FILE *opt_pipe           = NULL;
 349
 350 enum option_type {
 351         OPT_NONE,
 352         OPT_INT,
 353 };
 354
 355 static bool
 356 check_option(char *opt, char short_name, char *name, enum option_type type, ...)
 357 {
 358         va_list args;
 359         char *value = "";
 360         int *number;
 361
 362         if (opt[0] != '-')
 363                 return FALSE;
 364
 365         if (opt[1] == '-') {
 366                 int namelen = strlen(name);
 367
 368                 opt += 2;
 369
 370                 if (strncmp(opt, name, namelen))
 371                         return FALSE;
 372
 373                 if (opt[namelen] == '=')
 374                         value = opt + namelen + 1;
 375
 376         } else {
 377                 if (!short_name || opt[1] != short_name)
 378                         return FALSE;
 379                 value = opt + 2;
 380         }
 381
 382         va_start(args, type);
 383         if (type == OPT_INT) {
 384                 number = va_arg(args, int *);
 385                 if (isdigit(*value))
 386                         *number = atoi(value);
 387         }
 388         va_end(args);
 389
 390         return TRUE;
 391 }
 392
 393 /* Returns the index of log or diff command or -1 to exit. */
 394 static bool
 395 parse_options(int argc, char *argv[])
 396 {
 397         int i;
 398
 399         for (i = 1; i < argc; i++) {
 400                 char *opt = argv[i];
 401
 402                 if (!strcmp(opt, "-l")) {
 403                         opt_request = REQ_VIEW_LOG;
 404                         continue;
 405                 }
 406
 407                 if (!strcmp(opt, "-d")) {
 408                         opt_request = REQ_VIEW_DIFF;
 409                         continue;
 410                 }
 411
 412                 if (check_option(opt, 'n', "line-number", OPT_INT, &opt_num_interval)) {
 413                         opt_line_number = TRUE;
 414                         continue;
 415                 }
 416
 417                 if (check_option(opt, 'b', "tab-size", OPT_INT, &opt_tab_size)) {
 418                         opt_tab_size = MIN(opt_tab_size, TABSIZE);
 419                         continue;
 420                 }
 421
 422                 if (check_option(opt, 'v', "version", OPT_NONE)) {
 423                         printf("tig version %s\n", VERSION);
 424                         return FALSE;
 425                 }
 426
 427                 if (check_option(opt, 'h', "help", OPT_NONE)) {
 428                         printf(usage);
 429                         return FALSE;
 430                 }
 431
 432                 if (!strcmp(opt, "--")) {
 433                         i++;
 434                         break;
 435                 }
 436
 437                 if (!strcmp(opt, "log") ||
 438                     !strcmp(opt, "diff") ||
 439                     !strcmp(opt, "show")) {
 440                         opt_request = opt[0] == 'l'
 441                                     ? REQ_VIEW_LOG : REQ_VIEW_DIFF;
 442                         break;
 443                 }
 444
 445                 if (opt[0] && opt[0] != '-')
 446                         break;
 447
 448                 die("unknown option '%s'\n\n%s", opt, usage);
 449         }
 450
 451         if (!isatty(STDIN_FILENO)) {
 452                 opt_request = REQ_VIEW_PAGER;
 453                 opt_pipe = stdin;
 454
 455         } else if (i < argc) {
 456                 size_t buf_size;
 457
 458                 if (opt_request == REQ_VIEW_MAIN)
 459                         /* XXX: This is vulnerable to the user overriding
 460                          * options required for the main view parser. */
 461                         string_copy(opt_cmd, "git log --stat --pretty=raw");
 462                 else
 463                         string_copy(opt_cmd, "git");
 464                 buf_size = strlen(opt_cmd);
 465
 466                 while (buf_size < sizeof(opt_cmd) && i < argc) {
 467                         opt_cmd[buf_size++] = ' ';
 468                         buf_size = sq_quote(opt_cmd, buf_size, argv[i++]);
 469                 }
 470
 471                 if (buf_size >= sizeof(opt_cmd))
 472                         die("command too long");
 473
 474                 opt_cmd[buf_size] = 0;
 475
 476         }
 477
 478         if (*opt_encoding && strcasecmp(opt_encoding, "UTF-8"))
 479                 opt_utf8 = FALSE;
 480
 481         return TRUE;
 482 }
 483
 484
 485 /*
 486  * Line-oriented content detection.
 487  */
 488
 489 #define LINE_INFO \
 490 LINE(DIFF_HEADER,  "diff --git ",       COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 491 LINE(DIFF_CHUNK,   "@@",                COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
 492 LINE(DIFF_ADD,     "+",                 COLOR_GREEN,    COLOR_DEFAULT,  0), \
 493 LINE(DIFF_DEL,     "-",                 COLOR_RED,      COLOR_DEFAULT,  0), \
 494 LINE(DIFF_INDEX,        "index ",         COLOR_BLUE,   COLOR_DEFAULT,  0), \
 495 LINE(DIFF_OLDMODE,      "old file mode ", COLOR_YELLOW, COLOR_DEFAULT,  0), \
 496 LINE(DIFF_NEWMODE,      "new file mode ", COLOR_YELLOW, COLOR_DEFAULT,  0), \
 497 LINE(DIFF_COPY_FROM,    "copy from",      COLOR_YELLOW, COLOR_DEFAULT,  0), \
 498 LINE(DIFF_COPY_TO,      "copy to",        COLOR_YELLOW, COLOR_DEFAULT,  0), \
 499 LINE(DIFF_RENAME_FROM,  "rename from",    COLOR_YELLOW, COLOR_DEFAULT,  0), \
 500 LINE(DIFF_RENAME_TO,    "rename to",      COLOR_YELLOW, COLOR_DEFAULT,  0), \
 501 LINE(DIFF_SIMILARITY,   "similarity ",    COLOR_YELLOW, COLOR_DEFAULT,  0), \
 502 LINE(DIFF_DISSIMILARITY,"dissimilarity ", COLOR_YELLOW, COLOR_DEFAULT,  0), \
 503 LINE(DIFF_TREE,         "diff-tree ",     COLOR_BLUE,   COLOR_DEFAULT,  0), \
 504 LINE(PP_AUTHOR,    "Author: ",          COLOR_CYAN,     COLOR_DEFAULT,  0), \
 505 LINE(PP_COMMIT,    "Commit: ",          COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
 506 LINE(PP_MERGE,     "Merge: ",           COLOR_BLUE,     COLOR_DEFAULT,  0), \
 507 LINE(PP_DATE,      "Date:   ",          COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 508 LINE(PP_ADATE,     "AuthorDate: ",      COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 509 LINE(PP_CDATE,     "CommitDate: ",      COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 510 LINE(PP_REFS,      "Refs: ",            COLOR_RED,      COLOR_DEFAULT,  0), \
 511 LINE(COMMIT,       "commit ",           COLOR_GREEN,    COLOR_DEFAULT,  0), \
 512 LINE(PARENT,       "parent ",           COLOR_BLUE,     COLOR_DEFAULT,  0), \
 513 LINE(TREE,         "tree ",             COLOR_BLUE,     COLOR_DEFAULT,  0), \
 514 LINE(AUTHOR,       "author ",           COLOR_CYAN,     COLOR_DEFAULT,  0), \
 515 LINE(COMMITTER,    "committer ",        COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
 516 LINE(SIGNOFF,      "    Signed-off-by", COLOR_YELLOW,   COLOR_DEFAULT,  0), \
 517 LINE(DEFAULT,      "",                  COLOR_DEFAULT,  COLOR_DEFAULT,  A_NORMAL), \
 518 LINE(CURSOR,       "",                  COLOR_WHITE,    COLOR_GREEN,    A_BOLD), \
 519 LINE(STATUS,       "",                  COLOR_GREEN,    COLOR_DEFAULT,  0), \
 520 LINE(TITLE_BLUR,   "",                  COLOR_WHITE,    COLOR_BLUE,     0), \
 521 LINE(TITLE_FOCUS,  "",                  COLOR_WHITE,    COLOR_BLUE,     A_BOLD), \
 522 LINE(MAIN_DATE,    "",                  COLOR_BLUE,     COLOR_DEFAULT,  0), \
 523 LINE(MAIN_AUTHOR,  "",                  COLOR_GREEN,    COLOR_DEFAULT,  0), \
 524 LINE(MAIN_COMMIT,  "",                  COLOR_DEFAULT,  COLOR_DEFAULT,  0), \
 525 LINE(MAIN_DELIM,   "",                  COLOR_MAGENTA,  COLOR_DEFAULT,  0), \
 526 LINE(MAIN_TAG,     "",                  COLOR_MAGENTA,  COLOR_DEFAULT,  A_BOLD), \
 527 LINE(MAIN_REF,     "",                  COLOR_CYAN,     COLOR_DEFAULT,  A_BOLD), \
 528
 529 enum line_type {
 530 #define LINE(type, line, fg, bg, attr) \
 531         LINE_##type
 532         LINE_INFO
 533 #undef  LINE
 534 };
 535
 536 struct line_info {
 537         const char *name;       /* Option name. */
 538         int namelen;            /* Size of option name. */
 539         const char *line;       /* The start of line to match. */
 540         int linelen;            /* Size of string to match. */
 541         int fg, bg, attr;       /* Color and text attributes for the lines. */
 542 };
 543
 544 static struct line_info line_info[] = {
 545 #define LINE(type, line, fg, bg, attr) \
 546         { #type, STRING_SIZE(#type), (line), STRING_SIZE(line), (fg), (bg), (attr) }
 547         LINE_INFO
 548 #undef  LINE
 549 };
 550
 551 static enum line_type
 552 get_line_type(char *line)
 553 {
 554         int linelen = strlen(line);
 555         enum line_type type;
 556
 557         for (type = 0; type < ARRAY_SIZE(line_info); type++)
 558                 /* Case insensitive search matches Signed-off-by lines better. */
 559                 if (linelen >= line_info[type].linelen &&
 560                     !strncasecmp(line_info[type].line, line, line_info[type].linelen))
 561                         return type;
 562
 563         return LINE_DEFAULT;
 564 }
 565
 566 static inline int
 567 get_line_attr(enum line_type type)
 568 {
 569         assert(type < ARRAY_SIZE(line_info));
 570         return COLOR_PAIR(type) | line_info[type].attr;
 571 }
 572
 573 static struct line_info *
 574 get_line_info(char *name, int namelen)
 575 {
 576         enum line_type type;
 577
 578         for (type = 0; type < ARRAY_SIZE(line_info); type++)
 579                 if (namelen == line_info[type].namelen &&
 580                     !string_enum_compare(line_info[type].name, name, namelen))
 581                         return &line_info[type];
 582
 583         return NULL;
 584 }
 585
 586 static void
 587 init_colors(void)
 588 {
 589         int default_bg = COLOR_BLACK;
 590         int default_fg = COLOR_WHITE;
 591         enum line_type type;
 592
 593         start_color();
 594
 595         if (use_default_colors() != ERR) {
 596                 default_bg = -1;
 597                 default_fg = -1;
 598         }
 599
 600         for (type = 0; type < ARRAY_SIZE(line_info); type++) {
 601                 struct line_info *info = &line_info[type];
 602                 int bg = info->bg == COLOR_DEFAULT ? default_bg : info->bg;
 603                 int fg = info->fg == COLOR_DEFAULT ? default_fg : info->fg;
 604
 605                 init_pair(type, fg, bg);
 606         }
 607 }
 608
 609 struct line {
 610         enum line_type type;
 611         void *data;             /* User data */
 612 };
 613
 614
 615 /*
 616  * Keys
 617  */
 618
 619 struct keymap {
 620         int alias;
 621         int request;
 622 };
 623
 624 static struct keymap keymap[] = {
 625         /* View switching */
 626         { 'm',          REQ_VIEW_MAIN },
 627         { 'd',          REQ_VIEW_DIFF },
 628         { 'l',          REQ_VIEW_LOG },
 629         { 'p',          REQ_VIEW_PAGER },
 630         { 'h',          REQ_VIEW_HELP },
 631         { '?',          REQ_VIEW_HELP },
 632
 633         /* View manipulation */
 634         { 'q',          REQ_VIEW_CLOSE },
 635         { KEY_TAB,      REQ_VIEW_NEXT },
 636         { KEY_RETURN,   REQ_ENTER },
 637         { KEY_UP,       REQ_PREVIOUS },
 638         { KEY_DOWN,     REQ_NEXT },
 639
 640         /* Cursor navigation */
 641         { 'k',          REQ_MOVE_UP },
 642         { 'j',          REQ_MOVE_DOWN },
 643         { KEY_HOME,     REQ_MOVE_FIRST_LINE },
 644         { KEY_END,      REQ_MOVE_LAST_LINE },
 645         { KEY_NPAGE,    REQ_MOVE_PAGE_DOWN },
 646         { ' ',          REQ_MOVE_PAGE_DOWN },
 647         { KEY_PPAGE,    REQ_MOVE_PAGE_UP },
 648         { 'b',          REQ_MOVE_PAGE_UP },
 649         { '-',          REQ_MOVE_PAGE_UP },
 650
 651         /* Scrolling */
 652         { KEY_IC,       REQ_SCROLL_LINE_UP },
 653         { KEY_DC,       REQ_SCROLL_LINE_DOWN },
 654         { 'w',          REQ_SCROLL_PAGE_UP },
 655         { 's',          REQ_SCROLL_PAGE_DOWN },
 656
 657         /* Misc */
 658         { 'Q',          REQ_QUIT },
 659         { 'z',          REQ_STOP_LOADING },
 660         { 'v',          REQ_SHOW_VERSION },
 661         { 'r',          REQ_SCREEN_REDRAW },
 662         { 'n',          REQ_TOGGLE_LINENO },
 663         { 'g',          REQ_TOGGLE_REV_GRAPH},
 664         { ':',          REQ_PROMPT },
 665
 666         /* wgetch() with nodelay() enabled returns ERR when there's no input. */
 667         { ERR,          REQ_SCREEN_UPDATE },
 668
 669         /* Use the ncurses SIGWINCH handler. */
 670         { KEY_RESIZE,   REQ_SCREEN_RESIZE },
 671 };
 672
 673 static enum request
 674 get_request(int key)
 675 {
 676         int i;
 677
 678         for (i = 0; i < ARRAY_SIZE(keymap); i++)
 679                 if (keymap[i].alias == key)
 680                         return keymap[i].request;
 681
 682         return (enum request) key;
 683 }
 684
 685 struct key {
 686         char *name;
 687         int value;
 688 };
 689
 690 static struct key key_table[] = {
 691         { "Enter",      KEY_RETURN },
 692         { "Space",      ' ' },
 693         { "Backspace",  KEY_BACKSPACE },
 694         { "Tab",        KEY_TAB },
 695         { "Escape",     KEY_ESC },
 696         { "Left",       KEY_LEFT },
 697         { "Right",      KEY_RIGHT },
 698         { "Up",         KEY_UP },
 699         { "Down",       KEY_DOWN },
 700         { "Insert",     KEY_IC },
 701         { "Delete",     KEY_DC },
 702         { "Home",       KEY_HOME },
 703         { "End",        KEY_END },
 704         { "PageUp",     KEY_PPAGE },
 705         { "PageDown",   KEY_NPAGE },
 706         { "F1",         KEY_F(1) },
 707         { "F2",         KEY_F(2) },
 708         { "F3",         KEY_F(3) },
 709         { "F4",         KEY_F(4) },
 710         { "F5",         KEY_F(5) },
 711         { "F6",         KEY_F(6) },
 712         { "F7",         KEY_F(7) },
 713         { "F8",         KEY_F(8) },
 714         { "F9",         KEY_F(9) },
 715         { "F10",        KEY_F(10) },
 716         { "F11",        KEY_F(11) },
 717         { "F12",        KEY_F(12) },
 718 };
 719
 720 static char *
 721 get_key(enum request request)
 722 {
 723         static char buf[BUFSIZ];
 724         static char key_char[] = "'X'";
 725         int pos = 0;
 726         char *sep = "    ";
 727         int i;
 728
 729         buf[pos] = 0;
 730
 731         for (i = 0; i < ARRAY_SIZE(keymap); i++) {
 732                 char *seq = NULL;
 733                 int key;
 734
 735                 if (keymap[i].request != request)
 736                         continue;
 737
 738                 for (key = 0; key < ARRAY_SIZE(key_table); key++)
 739                         if (key_table[key].value == keymap[i].alias)
 740                                 seq = key_table[key].name;
 741
 742                 if (seq == NULL &&
 743                     keymap[i].alias < 127 &&
 744                     isprint(keymap[i].alias)) {
 745                         key_char[1] = (char) keymap[i].alias;
 746                         seq = key_char;
 747                 }
 748
 749                 if (!seq)
 750                         seq = "'?'";
 751
 752                 if (!string_format_from(buf, &pos, "%s%s", sep, seq))
 753                         return "Too many keybindings!";
 754                 sep = ", ";
 755         }
 756
 757         return buf;
 758 }
 759
 760
 761 /*
 762  * User config file handling.
 763  */
 764
 765 static struct int_map color_map[] = {
 766 #define COLOR_MAP(name) { #name, STRING_SIZE(#name), COLOR_##name }
 767         COLOR_MAP(DEFAULT),
 768         COLOR_MAP(BLACK),
 769         COLOR_MAP(BLUE),
 770         COLOR_MAP(CYAN),
 771         COLOR_MAP(GREEN),
 772         COLOR_MAP(MAGENTA),
 773         COLOR_MAP(RED),
 774         COLOR_MAP(WHITE),
 775         COLOR_MAP(YELLOW),
 776 };
 777
 778 #define set_color(color, name) \
 779         set_from_int_map(color_map, ARRAY_SIZE(color_map), color, name, strlen(name))
 780
 781 static struct int_map attr_map[] = {
 782 #define ATTR_MAP(name) { #name, STRING_SIZE(#name), A_##name }
 783         ATTR_MAP(NORMAL),
 784         ATTR_MAP(BLINK),
 785         ATTR_MAP(BOLD),
 786         ATTR_MAP(DIM),
 787         ATTR_MAP(REVERSE),
 788         ATTR_MAP(STANDOUT),
 789         ATTR_MAP(UNDERLINE),
 790 };
 791
 792 #define set_attribute(attr, name) \
 793         set_from_int_map(attr_map, ARRAY_SIZE(attr_map), attr, name, strlen(name))
 794
 795 static int   config_lineno;
 796 static bool  config_errors;
 797 static char *config_msg;
 798
 799 /* Wants: object fgcolor bgcolor [attr] */
 800 static int
 801 option_color_command(int argc, char *argv[])
 802 {
 803         struct line_info *info;
 804
 805         if (argc != 3 && argc != 4) {
 806                 config_msg = "Wrong number of arguments given to color command";
 807                 return ERR;
 808         }
 809
 810         info = get_line_info(argv[0], strlen(argv[0]));
 811         if (!info) {
 812                 config_msg = "Unknown color name";
 813                 return ERR;
 814         }
 815
 816         if (set_color(&info->fg, argv[1]) == ERR) {
 817                 config_msg = "Unknown color";
 818                 return ERR;
 819         }
 820
 821         if (set_color(&info->bg, argv[2]) == ERR) {
 822                 config_msg = "Unknown color";
 823                 return ERR;
 824         }
 825
 826         if (argc == 4 && set_attribute(&info->attr, argv[3]) == ERR) {
 827                 config_msg = "Unknown attribute";
 828                 return ERR;
 829         }
 830
 831         return OK;
 832 }
 833
 834 /* Wants: name = value */
 835 static int
 836 option_set_command(int argc, char *argv[])
 837 {
 838         if (argc != 3) {
 839                 config_msg = "Wrong number of arguments given to set command";
 840                 return ERR;
 841         }
 842
 843         if (strcmp(argv[1], "=")) {
 844                 config_msg = "No value assigned";
 845                 return ERR;
 846         }
 847
 848         if (!strcmp(argv[0], "show-rev-graph")) {
 849                 opt_rev_graph = (!strcmp(argv[2], "1") ||
 850                                  !strcmp(argv[2], "true") ||
 851                                  !strcmp(argv[2], "yes"));
 852                 return OK;
 853         }
 854
 855         if (!strcmp(argv[0], "line-number-interval")) {
 856                 opt_num_interval = atoi(argv[2]);
 857                 return OK;
 858         }
 859
 860         if (!strcmp(argv[0], "tab-size")) {
 861                 opt_tab_size = atoi(argv[2]);
 862                 return OK;
 863         }
 864
 865         if (!strcmp(argv[0], "encoding")) {
 866                 string_copy(opt_encoding, argv[2]);
 867                 return OK;
 868         }
 869
 870         return ERR;
 871 }
 872
 873 static int
 874 set_option(char *opt, char *value)
 875 {
 876         char *argv[16];
 877         int valuelen;
 878         int argc = 0;
 879
 880         /* Tokenize */
 881         while (argc < ARRAY_SIZE(argv) && (valuelen = strcspn(value, " \t"))) {
 882                 argv[argc++] = value;
 883
 884                 value += valuelen;
 885                 if (!*value)
 886                         break;
 887
 888                 *value++ = 0;
 889                 while (isspace(*value))
 890                         value++;
 891         }
 892
 893         if (!strcmp(opt, "color"))
 894                 return option_color_command(argc, argv);
 895
 896         if (!strcmp(opt, "set"))
 897                 return option_set_command(argc, argv);
 898
 899         return ERR;
 900 }
 901
 902 static int
 903 read_option(char *opt, int optlen, char *value, int valuelen)
 904 {
 905         config_lineno++;
 906         config_msg = "Internal error";
 907
 908         optlen = strcspn(opt, "#;");
 909         if (optlen == 0) {
 910                 /* The whole line is a commend or empty. */
 911                 return OK;
 912
 913         } else if (opt[optlen] != 0) {
 914                 /* Part of the option name is a comment, so the value part
 915                  * should be ignored. */
 916                 valuelen = 0;
 917                 opt[optlen] = value[valuelen] = 0;
 918         } else {
 919                 /* Else look for comment endings in the value. */
 920                 valuelen = strcspn(value, "#;");
 921                 value[valuelen] = 0;
 922         }
 923
 924         if (set_option(opt, value) == ERR) {
 925                 fprintf(stderr, "Error on line %d, near '%.*s' option: %s\n",
 926                         config_lineno, optlen, opt, config_msg);
 927                 config_errors = TRUE;
 928         }
 929
 930         /* Always keep going if errors are encountered. */
 931         return OK;
 932 }
 933
 934 static int
 935 load_options(void)
 936 {
 937         char *home = getenv("HOME");
 938         char buf[1024];
 939         FILE *file;
 940
 941         config_lineno = 0;
 942         config_errors = FALSE;
 943
 944         if (!home || !string_format(buf, "%s/.tigrc", home))
 945                 return ERR;
 946
 947         /* It's ok that the file doesn't exist. */
 948         file = fopen(buf, "r");
 949         if (!file)
 950                 return OK;
 951
 952         if (read_properties(file, " \t", read_option) == ERR ||
 953             config_errors == TRUE)
 954                 fprintf(stderr, "Errors while loading %s.\n", buf);
 955
 956         return OK;
 957 }
 958
 959
 960 /*
 961  * The viewer
 962  */
 963
 964 struct view;
 965 struct view_ops;
 966
 967 /* The display array of active views and the index of the current view. */
 968 static struct view *display[2];
 969 static unsigned int current_view;
 970
 971 #define foreach_view(view, i) \
 972         for (i = 0; i < ARRAY_SIZE(display) && (view = display[i]); i++)
 973
 974 #define displayed_views()       (display[1] != NULL ? 2 : 1)
 975
 976 /* Current head and commit ID */
 977 static char ref_commit[SIZEOF_REF]      = "HEAD";
 978 static char ref_head[SIZEOF_REF]        = "HEAD";
 979
 980 struct view {
 981         const char *name;       /* View name */
 982         const char *cmd_fmt;    /* Default command line format */
 983         const char *cmd_env;    /* Command line set via environment */
 984         const char *id;         /* Points to either of ref_{head,commit} */
 985
 986         struct view_ops *ops;   /* View operations */
 987
 988         char cmd[SIZEOF_CMD];   /* Command buffer */
 989         char ref[SIZEOF_REF];   /* Hovered commit reference */
 990         char vid[SIZEOF_REF];   /* View ID. Set to id member when updating. */
 991
 992         int height, width;      /* The width and height of the main window */
 993         WINDOW *win;            /* The main window */
 994         WINDOW *title;          /* The title window living below the main window */
 995
 996         /* Navigation */
 997         unsigned long offset;   /* Offset of the window top */
 998         unsigned long lineno;   /* Current line number */
 999
1000         /* If non-NULL, points to the view that opened this view. If this view
1001          * is closed tig will switch back to the parent view. */
1002         struct view *parent;
1003
1004         /* Buffering */
1005         unsigned long lines;    /* Total number of lines */
1006         struct line *line;      /* Line index */
1007         unsigned long line_size;/* Total number of allocated lines */
1008         unsigned int digits;    /* Number of digits in the lines member. */
1009
1010         /* Loading */
1011         FILE *pipe;
1012         time_t start_time;
1013 };
1014
1015 struct view_ops {
1016         /* What type of content being displayed. Used in the title bar. */
1017         const char *type;
1018         /* Draw one line; @lineno must be < view->height. */
1019         bool (*draw)(struct view *view, struct line *line, unsigned int lineno);
1020         /* Read one line; updates view->line. */
1021         bool (*read)(struct view *view, char *data);
1022         /* Depending on view, change display based on current line. */
1023         bool (*enter)(struct view *view, struct line *line);
1024 };
1025
1026 static struct view_ops pager_ops;
1027 static struct view_ops main_ops;
1028
1029 #define VIEW_STR(name, cmd, env, ref, ops) \
1030         { name, cmd, #env, ref, ops }
1031
1032 #define VIEW_(id, name, ops, ref) \
1033         VIEW_STR(name, TIG_##id##_CMD,  TIG_##id##_CMD, ref, ops)
1034
1035
1036 static struct view views[] = {
1037         VIEW_(MAIN,  "main",  &main_ops,  ref_head),
1038         VIEW_(DIFF,  "diff",  &pager_ops, ref_commit),
1039         VIEW_(LOG,   "log",   &pager_ops, ref_head),
1040         VIEW_(HELP,  "help",  &pager_ops, "static"),
1041         VIEW_(PAGER, "pager", &pager_ops, "static"),
1042 };
1043
1044 #define VIEW(req) (&views[(req) - REQ_OFFSET - 1])
1045
1046
1047 static bool
1048 draw_view_line(struct view *view, unsigned int lineno)
1049 {
1050         if (view->offset + lineno >= view->lines)
1051                 return FALSE;
1052
1053         return view->ops->draw(view, &view->line[view->offset + lineno], lineno);
1054 }
1055
1056 static void
1057 redraw_view_from(struct view *view, int lineno)
1058 {
1059         assert(0 <= lineno && lineno < view->height);
1060
1061         for (; lineno < view->height; lineno++) {
1062                 if (!draw_view_line(view, lineno))
1063                         break;
1064         }
1065
1066         redrawwin(view->win);
1067         wrefresh(view->win);
1068 }
1069
1070 static void
1071 redraw_view(struct view *view)
1072 {
1073         wclear(view->win);
1074         redraw_view_from(view, 0);
1075 }
1076
1077
1078 static void
1079 update_view_title(struct view *view)
1080 {
1081         if (view == display[current_view])
1082                 wbkgdset(view->title, get_line_attr(LINE_TITLE_FOCUS));
1083         else
1084                 wbkgdset(view->title, get_line_attr(LINE_TITLE_BLUR));
1085
1086         werase(view->title);
1087         wmove(view->title, 0, 0);
1088
1089         if (*view->ref)
1090                 wprintw(view->title, "[%s] %s", view->name, view->ref);
1091         else
1092                 wprintw(view->title, "[%s]", view->name);
1093
1094         if (view->lines || view->pipe) {
1095                 unsigned int view_lines = view->offset + view->height;
1096                 unsigned int lines = view->lines
1097                                    ? MIN(view_lines, view->lines) * 100 / view->lines
1098                                    : 0;
1099
1100                 wprintw(view->title, " - %s %d of %d (%d%%)",
1101                         view->ops->type,
1102                         view->lineno + 1,
1103                         view->lines,
1104                         lines);
1105         }
1106
1107         if (view->pipe) {
1108                 time_t secs = time(NULL) - view->start_time;
1109
1110                 /* Three git seconds are a long time ... */
1111                 if (secs > 2)
1112                         wprintw(view->title, " %lds", secs);
1113         }
1114
1115         wmove(view->title, 0, view->width - 1);
1116         wrefresh(view->title);
1117 }
1118
1119 static void
1120 resize_display(void)
1121 {
1122         int offset, i;
1123         struct view *base = display[0];
1124         struct view *view = display[1] ? display[1] : display[0];
1125
1126         /* Setup window dimensions */
1127
1128         getmaxyx(stdscr, base->height, base->width);
1129
1130         /* Make room for the status window. */
1131         base->height -= 1;
1132
1133         if (view != base) {
1134                 /* Horizontal split. */
1135                 view->width   = base->width;
1136                 view->height  = SCALE_SPLIT_VIEW(base->height);
1137                 base->height -= view->height;
1138
1139                 /* Make room for the title bar. */
1140                 view->height -= 1;
1141         }
1142
1143         /* Make room for the title bar. */
1144         base->height -= 1;
1145
1146         offset = 0;
1147
1148         foreach_view (view, i) {
1149                 if (!view->win) {
1150                         view->win = newwin(view->height, 0, offset, 0);
1151                         if (!view->win)
1152                                 die("Failed to create %s view", view->name);
1153
1154                         scrollok(view->win, TRUE);
1155
1156                         view->title = newwin(1, 0, offset + view->height, 0);
1157                         if (!view->title)
1158                                 die("Failed to create title window");
1159
1160                 } else {
1161                         wresize(view->win, view->height, view->width);
1162                         mvwin(view->win,   offset, 0);
1163                         mvwin(view->title, offset + view->height, 0);
1164                 }
1165
1166                 offset += view->height + 1;
1167         }
1168 }
1169
1170 static void
1171 redraw_display(void)
1172 {
1173         struct view *view;
1174         int i;
1175
1176         foreach_view (view, i) {
1177                 redraw_view(view);
1178                 update_view_title(view);
1179         }
1180 }
1181
1182 static void
1183 update_display_cursor(void)
1184 {
1185         struct view *view = display[current_view];
1186
1187         /* Move the cursor to the right-most column of the cursor line.
1188          *
1189          * XXX: This could turn out to be a bit expensive, but it ensures that
1190          * the cursor does not jump around. */
1191         if (view->lines) {
1192                 wmove(view->win, view->lineno - view->offset, view->width - 1);
1193                 wrefresh(view->win);
1194         }
1195 }
1196
1197 /*
1198  * Navigation
1199  */
1200
1201 /* Scrolling backend */
1202 static void
1203 do_scroll_view(struct view *view, int lines, bool redraw)
1204 {
1205         /* The rendering expects the new offset. */
1206         view->offset += lines;
1207
1208         assert(0 <= view->offset && view->offset < view->lines);
1209         assert(lines);
1210
1211         /* Redraw the whole screen if scrolling is pointless. */
1212         if (view->height < ABS(lines)) {
1213                 redraw_view(view);
1214
1215         } else {
1216                 int line = lines > 0 ? view->height - lines : 0;
1217                 int end = line + ABS(lines);
1218
1219                 wscrl(view->win, lines);
1220
1221                 for (; line < end; line++) {
1222                         if (!draw_view_line(view, line))
1223                                 break;
1224                 }
1225         }
1226
1227         /* Move current line into the view. */
1228         if (view->lineno < view->offset) {
1229                 view->lineno = view->offset;
1230                 draw_view_line(view, 0);
1231
1232         } else if (view->lineno >= view->offset + view->height) {
1233                 if (view->lineno == view->offset + view->height) {
1234                         /* Clear the hidden line so it doesn't show if the view
1235                          * is scrolled up. */
1236                         wmove(view->win, view->height, 0);
1237                         wclrtoeol(view->win);
1238                 }
1239                 view->lineno = view->offset + view->height - 1;
1240                 draw_view_line(view, view->lineno - view->offset);
1241         }
1242
1243         assert(view->offset <= view->lineno && view->lineno < view->lines);
1244
1245         if (!redraw)
1246                 return;
1247
1248         redrawwin(view->win);
1249         wrefresh(view->win);
1250         report("");
1251 }
1252
1253 /* Scroll frontend */
1254 static void
1255 scroll_view(struct view *view, enum request request)
1256 {
1257         int lines = 1;
1258
1259         switch (request) {
1260         case REQ_SCROLL_PAGE_DOWN:
1261                 lines = view->height;
1262         case REQ_SCROLL_LINE_DOWN:
1263                 if (view->offset + lines > view->lines)
1264                         lines = view->lines - view->offset;
1265
1266                 if (lines == 0 || view->offset + view->height >= view->lines) {
1267                         report("Cannot scroll beyond the last line");
1268                         return;
1269                 }
1270                 break;
1271
1272         case REQ_SCROLL_PAGE_UP:
1273                 lines = view->height;
1274         case REQ_SCROLL_LINE_UP:
1275                 if (lines > view->offset)
1276                         lines = view->offset;
1277
1278                 if (lines == 0) {
1279                         report("Cannot scroll beyond the first line");
1280                         return;
1281                 }
1282
1283                 lines = -lines;
1284                 break;
1285
1286         default:
1287                 die("request %d not handled in switch", request);
1288         }
1289
1290         do_scroll_view(view, lines, TRUE);
1291 }
1292
1293 /* Cursor moving */
1294 static void
1295 move_view(struct view *view, enum request request, bool redraw)
1296 {
1297         int steps;
1298
1299         switch (request) {
1300         case REQ_MOVE_FIRST_LINE:
1301                 steps = -view->lineno;
1302                 break;
1303
1304         case REQ_MOVE_LAST_LINE:
1305                 steps = view->lines - view->lineno - 1;
1306                 break;
1307
1308         case REQ_MOVE_PAGE_UP:
1309                 steps = view->height > view->lineno
1310                       ? -view->lineno : -view->height;
1311                 break;
1312
1313         case REQ_MOVE_PAGE_DOWN:
1314                 steps = view->lineno + view->height >= view->lines
1315                       ? view->lines - view->lineno - 1 : view->height;
1316                 break;
1317
1318         case REQ_MOVE_UP:
1319                 steps = -1;
1320                 break;
1321
1322         case REQ_MOVE_DOWN:
1323                 steps = 1;
1324                 break;
1325
1326         default:
1327                 die("request %d not handled in switch", request);
1328         }
1329
1330         if (steps <= 0 && view->lineno == 0) {
1331                 report("Cannot move beyond the first line");
1332                 return;
1333
1334         } else if (steps >= 0 && view->lineno + 1 >= view->lines) {
1335                 report("Cannot move beyond the last line");
1336                 return;
1337         }
1338
1339         /* Move the current line */
1340         view->lineno += steps;
1341         assert(0 <= view->lineno && view->lineno < view->lines);
1342
1343         /* Repaint the old "current" line if we be scrolling */
1344         if (ABS(steps) < view->height) {
1345                 int prev_lineno = view->lineno - steps - view->offset;
1346
1347                 wmove(view->win, prev_lineno, 0);
1348                 wclrtoeol(view->win);
1349                 draw_view_line(view,  prev_lineno);
1350         }
1351
1352         /* Check whether the view needs to be scrolled */
1353         if (view->lineno < view->offset ||
1354             view->lineno >= view->offset + view->height) {
1355                 if (steps < 0 && -steps > view->offset) {
1356                         steps = -view->offset;
1357
1358                 } else if (steps > 0) {
1359                         if (view->lineno == view->lines - 1 &&
1360                             view->lines > view->height) {
1361                                 steps = view->lines - view->offset - 1;
1362                                 if (steps >= view->height)
1363                                         steps -= view->height - 1;
1364                         }
1365                 }
1366
1367                 do_scroll_view(view, steps, redraw);
1368                 return;
1369         }
1370
1371         /* Draw the current line */
1372         draw_view_line(view, view->lineno - view->offset);
1373
1374         if (!redraw)
1375                 return;
1376
1377         redrawwin(view->win);
1378         wrefresh(view->win);
1379         report("");
1380 }
1381
1382
1383 /*
1384  * Incremental updating
1385  */
1386
1387 static void
1388 end_update(struct view *view)
1389 {
1390         if (!view->pipe)
1391                 return;
1392         set_nonblocking_input(FALSE);
1393         if (view->pipe == stdin)
1394                 fclose(view->pipe);
1395         else
1396                 pclose(view->pipe);
1397         view->pipe = NULL;
1398 }
1399
1400 static bool
1401 begin_update(struct view *view)
1402 {
1403         const char *id = view->id;
1404
1405         if (view->pipe)
1406                 end_update(view);
1407
1408         if (opt_cmd[0]) {
1409                 string_copy(view->cmd, opt_cmd);
1410                 opt_cmd[0] = 0;
1411                 /* When running random commands, the view ref could have become
1412                  * invalid so clear it. */
1413                 view->ref[0] = 0;
1414         } else {
1415                 const char *format = view->cmd_env ? view->cmd_env : view->cmd_fmt;
1416
1417                 if (!string_format(view->cmd, format, id, id, id, id, id))
1418                         return FALSE;
1419         }
1420
1421         /* Special case for the pager view. */
1422         if (opt_pipe) {
1423                 view->pipe = opt_pipe;
1424                 opt_pipe = NULL;
1425         } else {
1426                 view->pipe = popen(view->cmd, "r");
1427         }
1428
1429         if (!view->pipe)
1430                 return FALSE;
1431
1432         set_nonblocking_input(TRUE);
1433
1434         view->offset = 0;
1435         view->lines  = 0;
1436         view->lineno = 0;
1437         string_copy(view->vid, id);
1438
1439         if (view->line) {
1440                 int i;
1441
1442                 for (i = 0; i < view->lines; i++)
1443                         if (view->line[i].data)
1444                                 free(view->line[i].data);
1445
1446                 free(view->line);
1447                 view->line = NULL;
1448         }
1449
1450         view->start_time = time(NULL);
1451
1452         return TRUE;
1453 }
1454
1455 static struct line *
1456 realloc_lines(struct view *view, size_t line_size)
1457 {
1458         struct line *tmp = realloc(view->line, sizeof(*view->line) * line_size);
1459
1460         if (!tmp)
1461                 return NULL;
1462
1463         view->line = tmp;
1464         view->line_size = line_size;
1465         return view->line;
1466 }
1467
1468 static bool
1469 update_view(struct view *view)
1470 {
1471         char buffer[BUFSIZ];
1472         char *line;
1473         /* The number of lines to read. If too low it will cause too much
1474          * redrawing (and possible flickering), if too high responsiveness
1475          * will suffer. */
1476         unsigned long lines = view->height;
1477         int redraw_from = -1;
1478
1479         if (!view->pipe)
1480                 return TRUE;
1481
1482         /* Only redraw if lines are visible. */
1483         if (view->offset + view->height >= view->lines)
1484                 redraw_from = view->lines - view->offset;
1485
1486         if (!realloc_lines(view, view->lines + lines))
1487                 goto alloc_error;
1488
1489         while ((line = fgets(buffer, sizeof(buffer), view->pipe))) {
1490                 int linelen = strlen(line);
1491
1492                 if (linelen)
1493                         line[linelen - 1] = 0;
1494
1495                 if (!view->ops->read(view, line))
1496                         goto alloc_error;
1497
1498                 if (lines-- == 1)
1499                         break;
1500         }
1501
1502         {
1503                 int digits;
1504
1505                 lines = view->lines;
1506                 for (digits = 0; lines; digits++)
1507                         lines /= 10;
1508
1509                 /* Keep the displayed view in sync with line number scaling. */
1510                 if (digits != view->digits) {
1511                         view->digits = digits;
1512                         redraw_from = 0;
1513                 }
1514         }
1515
1516         if (redraw_from >= 0) {
1517                 /* If this is an incremental update, redraw the previous line
1518                  * since for commits some members could have changed when
1519                  * loading the main view. */
1520                 if (redraw_from > 0)
1521                         redraw_from--;
1522
1523                 /* Incrementally draw avoids flickering. */
1524                 redraw_view_from(view, redraw_from);
1525         }
1526
1527         /* Update the title _after_ the redraw so that if the redraw picks up a
1528          * commit reference in view->ref it'll be available here. */
1529         update_view_title(view);
1530
1531         if (ferror(view->pipe)) {
1532                 report("Failed to read: %s", strerror(errno));
1533                 goto end;
1534
1535         } else if (feof(view->pipe)) {
1536                 report("");
1537                 goto end;
1538         }
1539
1540         return TRUE;
1541
1542 alloc_error:
1543         report("Allocation failure");
1544
1545 end:
1546         end_update(view);
1547         return FALSE;
1548 }
1549
1550
1551 /*
1552  * View opening
1553  */
1554
1555 static void open_help_view(struct view *view)
1556 {
1557         char buf[BUFSIZ];
1558         int lines = ARRAY_SIZE(req_info) + 2;
1559         int i;
1560
1561         if (view->lines > 0)
1562                 return;
1563
1564         for (i = 0; i < ARRAY_SIZE(req_info); i++)
1565                 if (!req_info[i].request)
1566                         lines++;
1567
1568         view->line = calloc(lines, sizeof(*view->line));
1569         if (!view->line) {
1570                 report("Allocation failure");
1571                 return;
1572         }
1573
1574         view->ops->read(view, "Quick reference for tig keybindings:");
1575
1576         for (i = 0; i < ARRAY_SIZE(req_info); i++) {
1577                 char *key;
1578
1579                 if (!req_info[i].request) {
1580                         view->ops->read(view, "");
1581                         view->ops->read(view, req_info[i].help);
1582                         continue;
1583                 }
1584
1585                 key = get_key(req_info[i].request);
1586                 if (!string_format(buf, "%-25s %s", key, req_info[i].help))
1587                         continue;
1588
1589                 view->ops->read(view, buf);
1590         }
1591 }
1592
1593 enum open_flags {
1594         OPEN_DEFAULT = 0,       /* Use default view switching. */
1595         OPEN_SPLIT = 1,         /* Split current view. */
1596         OPEN_BACKGROUNDED = 2,  /* Backgrounded. */
1597         OPEN_RELOAD = 4,        /* Reload view even if it is the current. */
1598 };
1599
1600 static void
1601 open_view(struct view *prev, enum request request, enum open_flags flags)
1602 {
1603         bool backgrounded = !!(flags & OPEN_BACKGROUNDED);
1604         bool split = !!(flags & OPEN_SPLIT);
1605         bool reload = !!(flags & OPEN_RELOAD);
1606         struct view *view = VIEW(request);
1607         int nviews = displayed_views();
1608         struct view *base_view = display[0];
1609
1610         if (view == prev && nviews == 1 && !reload) {
1611                 report("Already in %s view", view->name);
1612                 return;
1613         }
1614
1615         if (view == VIEW(REQ_VIEW_HELP)) {
1616                 open_help_view(view);
1617
1618         } else if ((reload || strcmp(view->vid, view->id)) &&
1619                    !begin_update(view)) {
1620                 report("Failed to load %s view", view->name);
1621                 return;
1622         }
1623
1624         if (split) {
1625                 display[1] = view;
1626                 if (!backgrounded)
1627                         current_view = 1;
1628         } else {
1629                 /* Maximize the current view. */
1630                 memset(display, 0, sizeof(display));
1631                 current_view = 0;
1632                 display[current_view] = view;
1633         }
1634
1635         /* Resize the view when switching between split- and full-screen,
1636          * or when switching between two different full-screen views. */
1637         if (nviews != displayed_views() ||
1638             (nviews == 1 && base_view != display[0]))
1639                 resize_display();
1640
1641         if (split && prev->lineno - prev->offset >= prev->height) {
1642                 /* Take the title line into account. */
1643                 int lines = prev->lineno - prev->offset - prev->height + 1;
1644
1645                 /* Scroll the view that was split if the current line is
1646                  * outside the new limited view. */
1647                 do_scroll_view(prev, lines, TRUE);
1648         }
1649
1650         if (prev && view != prev) {
1651                 if (split && !backgrounded) {
1652                         /* "Blur" the previous view. */
1653                         update_view_title(prev);
1654                 }
1655
1656                 view->parent = prev;
1657         }
1658
1659         if (view->pipe && view->lines == 0) {
1660                 /* Clear the old view and let the incremental updating refill
1661                  * the screen. */
1662                 wclear(view->win);
1663                 report("");
1664         } else {
1665                 redraw_view(view);
1666                 report("");
1667         }
1668
1669         /* If the view is backgrounded the above calls to report()
1670          * won't redraw the view title. */
1671         if (backgrounded)
1672                 update_view_title(view);
1673 }
1674
1675
1676 /*
1677  * User request switch noodle
1678  */
1679
1680 static int
1681 view_driver(struct view *view, enum request request)
1682 {
1683         int i;
1684
1685         switch (request) {
1686         case REQ_MOVE_UP:
1687         case REQ_MOVE_DOWN:
1688         case REQ_MOVE_PAGE_UP:
1689         case REQ_MOVE_PAGE_DOWN:
1690         case REQ_MOVE_FIRST_LINE:
1691         case REQ_MOVE_LAST_LINE:
1692                 move_view(view, request, TRUE);
1693                 break;
1694
1695         case REQ_SCROLL_LINE_DOWN:
1696         case REQ_SCROLL_LINE_UP:
1697         case REQ_SCROLL_PAGE_DOWN:
1698         case REQ_SCROLL_PAGE_UP:
1699                 scroll_view(view, request);
1700                 break;
1701
1702         case REQ_VIEW_MAIN:
1703         case REQ_VIEW_DIFF:
1704         case REQ_VIEW_LOG:
1705         case REQ_VIEW_HELP:
1706         case REQ_VIEW_PAGER:
1707                 open_view(view, request, OPEN_DEFAULT);
1708                 break;
1709
1710         case REQ_NEXT:
1711         case REQ_PREVIOUS:
1712                 request = request == REQ_NEXT ? REQ_MOVE_DOWN : REQ_MOVE_UP;
1713
1714                 if (view == VIEW(REQ_VIEW_DIFF) &&
1715                     view->parent == VIEW(REQ_VIEW_MAIN)) {
1716                         bool redraw = display[1] == view;
1717
1718                         view = view->parent;
1719                         move_view(view, request, redraw);
1720                         if (redraw)
1721                                 update_view_title(view);
1722                 } else {
1723                         move_view(view, request, TRUE);
1724                         break;
1725                 }
1726                 /* Fall-through */
1727
1728         case REQ_ENTER:
1729                 if (!view->lines) {
1730                         report("Nothing to enter");
1731                         break;
1732                 }
1733                 return view->ops->enter(view, &view->line[view->lineno]);
1734
1735         case REQ_VIEW_NEXT:
1736         {
1737                 int nviews = displayed_views();
1738                 int next_view = (current_view + 1) % nviews;
1739
1740                 if (next_view == current_view) {
1741                         report("Only one view is displayed");
1742                         break;
1743                 }
1744
1745                 current_view = next_view;
1746                 /* Blur out the title of the previous view. */
1747                 update_view_title(view);
1748                 report("");
1749                 break;
1750         }
1751         case REQ_TOGGLE_LINENO:
1752                 opt_line_number = !opt_line_number;
1753                 redraw_display();
1754                 break;
1755
1756         case REQ_TOGGLE_REV_GRAPH:
1757                 opt_rev_graph = !opt_rev_graph;
1758                 redraw_display();
1759                 break;
1760
1761         case REQ_PROMPT:
1762                 /* Always reload^Wrerun commands from the prompt. */
1763                 open_view(view, opt_request, OPEN_RELOAD);
1764                 break;
1765
1766         case REQ_STOP_LOADING:
1767                 for (i = 0; i < ARRAY_SIZE(views); i++) {
1768                         view = &views[i];
1769                         if (view->pipe)
1770                                 report("Stopped loading the %s view", view->name),
1771                         end_update(view);
1772                 }
1773                 break;
1774
1775         case REQ_SHOW_VERSION:
1776                 report("%s (built %s)", VERSION, __DATE__);
1777                 return TRUE;
1778
1779         case REQ_SCREEN_RESIZE:
1780                 resize_display();
1781                 /* Fall-through */
1782         case REQ_SCREEN_REDRAW:
1783                 redraw_display();
1784                 break;
1785
1786         case REQ_SCREEN_UPDATE:
1787                 doupdate();
1788                 return TRUE;
1789
1790         case REQ_VIEW_CLOSE:
1791                 /* XXX: Mark closed views by letting view->parent point to the
1792                  * view itself. Parents to closed view should never be
1793                  * followed. */
1794                 if (view->parent &&
1795                     view->parent->parent != view->parent) {
1796                         memset(display, 0, sizeof(display));
1797                         current_view = 0;
1798                         display[current_view] = view->parent;
1799                         view->parent = view;
1800                         resize_display();
1801                         redraw_display();
1802                         break;
1803                 }
1804                 /* Fall-through */
1805         case REQ_QUIT:
1806                 return FALSE;
1807
1808         default:
1809                 /* An unknown key will show most commonly used commands. */
1810                 report("Unknown key, press 'h' for help");
1811                 return TRUE;
1812         }
1813
1814         return TRUE;
1815 }
1816
1817
1818 /*
1819  * Pager backend
1820  */
1821
1822 static bool
1823 pager_draw(struct view *view, struct line *line, unsigned int lineno)
1824 {
1825         char *text = line->data;
1826         enum line_type type = line->type;
1827         int textlen = strlen(text);
1828         int attr;
1829
1830         wmove(view->win, lineno, 0);
1831
1832         if (view->offset + lineno == view->lineno) {
1833                 if (type == LINE_COMMIT) {
1834                         string_copy(view->ref, text + 7);
1835                         string_copy(ref_commit, view->ref);
1836                 }
1837
1838                 type = LINE_CURSOR;
1839                 wchgat(view->win, -1, 0, type, NULL);
1840         }
1841
1842         attr = get_line_attr(type);
1843         wattrset(view->win, attr);
1844
1845         if (opt_line_number || opt_tab_size < TABSIZE) {
1846                 static char spaces[] = "                    ";
1847                 int col_offset = 0, col = 0;
1848
1849                 if (opt_line_number) {
1850                         unsigned long real_lineno = view->offset + lineno + 1;
1851
1852                         if (real_lineno == 1 ||
1853                             (real_lineno % opt_num_interval) == 0) {
1854                                 wprintw(view->win, "%.*d", view->digits, real_lineno);
1855
1856                         } else {
1857                                 waddnstr(view->win, spaces,
1858                                          MIN(view->digits, STRING_SIZE(spaces)));
1859                         }
1860                         waddstr(view->win, ": ");
1861                         col_offset = view->digits + 2;
1862                 }
1863
1864                 while (text && col_offset + col < view->width) {
1865                         int cols_max = view->width - col_offset - col;
1866                         char *pos = text;
1867                         int cols;
1868
1869                         if (*text == '\t') {
1870                                 text++;
1871                                 assert(sizeof(spaces) > TABSIZE);
1872                                 pos = spaces;
1873                                 cols = opt_tab_size - (col % opt_tab_size);
1874
1875                         } else {
1876                                 text = strchr(text, '\t');
1877                                 cols = line ? text - pos : strlen(pos);
1878                         }
1879
1880                         waddnstr(view->win, pos, MIN(cols, cols_max));
1881                         col += cols;
1882                 }
1883
1884         } else {
1885                 int col = 0, pos = 0;
1886
1887                 for (; pos < textlen && col < view->width; pos++, col++)
1888                         if (text[pos] == '\t')
1889                                 col += TABSIZE - (col % TABSIZE) - 1;
1890
1891                 waddnstr(view->win, text, pos);
1892         }
1893
1894         return TRUE;
1895 }
1896
1897 static void
1898 add_pager_refs(struct view *view, struct line *line)
1899 {
1900         char buf[1024];
1901         char *data = line->data;
1902         struct ref **refs;
1903         int bufpos = 0, refpos = 0;
1904         const char *sep = "Refs: ";
1905
1906         assert(line->type == LINE_COMMIT);
1907
1908         refs = get_refs(data + STRING_SIZE("commit "));
1909         if (!refs)
1910                 return;
1911
1912         do {
1913                 struct ref *ref = refs[refpos];
1914                 char *fmt = ref->tag ? "%s[%s]" : "%s%s";
1915
1916                 if (!string_format_from(buf, &bufpos, fmt, sep, ref->name))
1917                         return;
1918                 sep = ", ";
1919         } while (refs[refpos++]->next);
1920
1921         if (!realloc_lines(view, view->line_size + 1))
1922                 return;
1923
1924         line = &view->line[view->lines];
1925         line->data = strdup(buf);
1926         if (!line->data)
1927                 return;
1928
1929         line->type = LINE_PP_REFS;
1930         view->lines++;
1931 }
1932
1933 static bool
1934 pager_read(struct view *view, char *data)
1935 {
1936         struct line *line = &view->line[view->lines];
1937
1938         line->data = strdup(data);
1939         if (!line->data)
1940                 return FALSE;
1941
1942         line->type = get_line_type(line->data);
1943         view->lines++;
1944
1945         if (line->type == LINE_COMMIT &&
1946             (view == VIEW(REQ_VIEW_DIFF) ||
1947              view == VIEW(REQ_VIEW_LOG)))
1948                 add_pager_refs(view, line);
1949
1950         return TRUE;
1951 }
1952
1953 static bool
1954 pager_enter(struct view *view, struct line *line)
1955 {
1956         int split = 0;
1957
1958         if (line->type == LINE_COMMIT &&
1959            (view == VIEW(REQ_VIEW_LOG) ||
1960             view == VIEW(REQ_VIEW_PAGER))) {
1961                 open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
1962                 split = 1;
1963         }
1964
1965         /* Always scroll the view even if it was split. That way
1966          * you can use Enter to scroll through the log view and
1967          * split open each commit diff. */
1968         scroll_view(view, REQ_SCROLL_LINE_DOWN);
1969
1970         /* FIXME: A minor workaround. Scrolling the view will call report("")
1971          * but if we are scrolling a non-current view this won't properly
1972          * update the view title. */
1973         if (split)
1974                 update_view_title(view);
1975
1976         return TRUE;
1977 }
1978
1979 static struct view_ops pager_ops = {
1980         "line",
1981         pager_draw,
1982         pager_read,
1983         pager_enter,
1984 };
1985
1986
1987 /*
1988  * Main view backend
1989  */
1990
1991 struct commit {
1992         char id[41];                    /* SHA1 ID. */
1993         char title[75];                 /* First line of the commit message. */
1994         char author[75];                /* Author of the commit. */
1995         struct tm time;                 /* Date from the author ident. */
1996         struct ref **refs;              /* Repository references. */
1997         chtype graph[SIZEOF_REVGRAPH];  /* Ancestry chain graphics. */
1998         size_t graph_size;              /* The width of the graph array. */
1999 };
2000
2001 static bool
2002 main_draw(struct view *view, struct line *line, unsigned int lineno)
2003 {
2004         char buf[DATE_COLS + 1];
2005         struct commit *commit = line->data;
2006         enum line_type type;
2007         int col = 0;
2008         size_t timelen;
2009         size_t authorlen;
2010         int trimmed = 1;
2011
2012         if (!*commit->author)
2013                 return FALSE;
2014
2015         wmove(view->win, lineno, col);
2016
2017         if (view->offset + lineno == view->lineno) {
2018                 string_copy(view->ref, commit->id);
2019                 string_copy(ref_commit, view->ref);
2020                 type = LINE_CURSOR;
2021                 wattrset(view->win, get_line_attr(type));
2022                 wchgat(view->win, -1, 0, type, NULL);
2023
2024         } else {
2025                 type = LINE_MAIN_COMMIT;
2026                 wattrset(view->win, get_line_attr(LINE_MAIN_DATE));
2027         }
2028
2029         timelen = strftime(buf, sizeof(buf), DATE_FORMAT, &commit->time);
2030         waddnstr(view->win, buf, timelen);
2031         waddstr(view->win, " ");
2032
2033         col += DATE_COLS;
2034         wmove(view->win, lineno, col);
2035         if (type != LINE_CURSOR)
2036                 wattrset(view->win, get_line_attr(LINE_MAIN_AUTHOR));
2037
2038         if (opt_utf8) {
2039                 authorlen = utf8_length(commit->author, AUTHOR_COLS - 2, &col, &trimmed);
2040         } else {
2041                 authorlen = strlen(commit->author);
2042                 if (authorlen > AUTHOR_COLS - 2) {
2043                         authorlen = AUTHOR_COLS - 2;
2044                         trimmed = 1;
2045                 }
2046         }
2047
2048         if (trimmed) {
2049                 waddnstr(view->win, commit->author, authorlen);
2050                 if (type != LINE_CURSOR)
2051                         wattrset(view->win, get_line_attr(LINE_MAIN_DELIM));
2052                 waddch(view->win, '~');
2053         } else {
2054                 waddstr(view->win, commit->author);
2055         }
2056
2057         col += AUTHOR_COLS;
2058         if (type != LINE_CURSOR)
2059                 wattrset(view->win, A_NORMAL);
2060
2061         if (opt_rev_graph && commit->graph_size) {
2062                 size_t i;
2063
2064                 wmove(view->win, lineno, col);
2065                 /* Using waddch() instead of waddnstr() ensures that
2066                  * they'll be rendered correctly for the cursor line. */
2067                 for (i = 0; i < commit->graph_size; i++)
2068                         waddch(view->win, commit->graph[i]);
2069
2070                 col += commit->graph_size + 1;
2071         }
2072
2073         wmove(view->win, lineno, col);
2074
2075         if (commit->refs) {
2076                 size_t i = 0;
2077
2078                 do {
2079                         if (type == LINE_CURSOR)
2080                                 ;
2081                         else if (commit->refs[i]->tag)
2082                                 wattrset(view->win, get_line_attr(LINE_MAIN_TAG));
2083                         else
2084                                 wattrset(view->win, get_line_attr(LINE_MAIN_REF));
2085                         waddstr(view->win, "[");
2086                         waddstr(view->win, commit->refs[i]->name);
2087                         waddstr(view->win, "]");
2088                         if (type != LINE_CURSOR)
2089                                 wattrset(view->win, A_NORMAL);
2090                         waddstr(view->win, " ");
2091                         col += strlen(commit->refs[i]->name) + STRING_SIZE("[] ");
2092                 } while (commit->refs[i++]->next);
2093         }
2094
2095         if (type != LINE_CURSOR)
2096                 wattrset(view->win, get_line_attr(type));
2097
2098         {
2099                 int titlelen = strlen(commit->title);
2100
2101                 if (col + titlelen > view->width)
2102                         titlelen = view->width - col;
2103
2104                 waddnstr(view->win, commit->title, titlelen);
2105         }
2106
2107         return TRUE;
2108 }
2109
2110 /* Reads git log --pretty=raw output and parses it into the commit struct. */
2111 static bool
2112 main_read(struct view *view, char *line)
2113 {
2114         enum line_type type = get_line_type(line);
2115         struct commit *commit = view->lines
2116                               ? view->line[view->lines - 1].data : NULL;
2117
2118         switch (type) {
2119         case LINE_COMMIT:
2120                 commit = calloc(1, sizeof(struct commit));
2121                 if (!commit)
2122                         return FALSE;
2123
2124                 line += STRING_SIZE("commit ");
2125
2126                 view->line[view->lines++].data = commit;
2127                 string_copy(commit->id, line);
2128                 commit->refs = get_refs(commit->id);
2129                 commit->graph[commit->graph_size++] = ACS_LTEE;
2130                 break;
2131
2132         case LINE_AUTHOR:
2133         {
2134                 char *ident = line + STRING_SIZE("author ");
2135                 char *end = strchr(ident, '<');
2136
2137                 if (!commit)
2138                         break;
2139
2140                 if (end) {
2141                         for (; end > ident && isspace(end[-1]); end--) ;
2142                         *end = 0;
2143                 }
2144
2145                 string_copy(commit->author, ident);
2146
2147                 /* Parse epoch and timezone */
2148                 if (end) {
2149                         char *secs = strchr(end + 1, '>');
2150                         char *zone;
2151                         time_t time;
2152
2153                         if (!secs || secs[1] != ' ')
2154                                 break;
2155
2156                         secs += 2;
2157                         time = (time_t) atol(secs);
2158                         zone = strchr(secs, ' ');
2159                         if (zone && strlen(zone) == STRING_SIZE(" +0700")) {
2160                                 long tz;
2161
2162                                 zone++;
2163                                 tz  = ('0' - zone[1]) * 60 * 60 * 10;
2164                                 tz += ('0' - zone[2]) * 60 * 60;
2165                                 tz += ('0' - zone[3]) * 60;
2166                                 tz += ('0' - zone[4]) * 60;
2167
2168                                 if (zone[0] == '-')
2169                                         tz = -tz;
2170
2171                                 time -= tz;
2172                         }
2173                         gmtime_r(&time, &commit->time);
2174                 }
2175                 break;
2176         }
2177         default:
2178                 if (!commit)
2179                         break;
2180
2181                 /* Fill in the commit title if it has not already been set. */
2182                 if (commit->title[0])
2183                         break;
2184
2185                 /* Require titles to start with a non-space character at the
2186                  * offset used by git log. */
2187                 /* FIXME: More gracefull handling of titles; append "..." to
2188                  * shortened titles, etc. */
2189                 if (strncmp(line, "    ", 4) ||
2190                     isspace(line[4]))
2191                         break;
2192
2193                 string_copy(commit->title, line + 4);
2194         }
2195
2196         return TRUE;
2197 }
2198
2199 static bool
2200 main_enter(struct view *view, struct line *line)
2201 {
2202         enum open_flags flags = display[0] == view ? OPEN_SPLIT : OPEN_DEFAULT;
2203
2204         open_view(view, REQ_VIEW_DIFF, flags);
2205         return TRUE;
2206 }
2207
2208 static struct view_ops main_ops = {
2209         "commit",
2210         main_draw,
2211         main_read,
2212         main_enter,
2213 };
2214
2215
2216 /*
2217  * Unicode / UTF-8 handling
2218  *
2219  * NOTE: Much of the following code for dealing with unicode is derived from
2220  * ELinks' UTF-8 code developed by Scrool <scroolik@gmail.com>. Origin file is
2221  * src/intl/charset.c from the utf8 branch commit elinks-0.11.0-g31f2c28.
2222  */
2223
2224 /* I've (over)annotated a lot of code snippets because I am not entirely
2225  * confident that the approach taken by this small UTF-8 interface is correct.
2226  * --jonas */
2227
2228 static inline int
2229 unicode_width(unsigned long c)
2230 {
2231         if (c >= 0x1100 &&
2232            (c <= 0x115f                         /* Hangul Jamo */
2233             || c == 0x2329
2234             || c == 0x232a
2235             || (c >= 0x2e80  && c <= 0xa4cf && c != 0x303f)
2236                                                 /* CJK ... Yi */
2237             || (c >= 0xac00  && c <= 0xd7a3)    /* Hangul Syllables */
2238             || (c >= 0xf900  && c <= 0xfaff)    /* CJK Compatibility Ideographs */
2239             || (c >= 0xfe30  && c <= 0xfe6f)    /* CJK Compatibility Forms */
2240             || (c >= 0xff00  && c <= 0xff60)    /* Fullwidth Forms */
2241             || (c >= 0xffe0  && c <= 0xffe6)
2242             || (c >= 0x20000 && c <= 0x2fffd)
2243             || (c >= 0x30000 && c <= 0x3fffd)))
2244                 return 2;
2245
2246         return 1;
2247 }
2248
2249 /* Number of bytes used for encoding a UTF-8 character indexed by first byte.
2250  * Illegal bytes are set one. */
2251 static const unsigned char utf8_bytes[256] = {
2252         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,
2253         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,
2254         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,
2255         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,
2256         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,
2257         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,
2258         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,
2259         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,
2260 };
2261
2262 /* Decode UTF-8 multi-byte representation into a unicode character. */
2263 static inline unsigned long
2264 utf8_to_unicode(const char *string, size_t length)
2265 {
2266         unsigned long unicode;
2267
2268         switch (length) {
2269         case 1:
2270                 unicode  =   string[0];
2271                 break;
2272         case 2:
2273                 unicode  =  (string[0] & 0x1f) << 6;
2274                 unicode +=  (string[1] & 0x3f);
2275                 break;
2276         case 3:
2277                 unicode  =  (string[0] & 0x0f) << 12;
2278                 unicode += ((string[1] & 0x3f) << 6);
2279                 unicode +=  (string[2] & 0x3f);
2280                 break;
2281         case 4:
2282                 unicode  =  (string[0] & 0x0f) << 18;
2283                 unicode += ((string[1] & 0x3f) << 12);
2284                 unicode += ((string[2] & 0x3f) << 6);
2285                 unicode +=  (string[3] & 0x3f);
2286                 break;
2287         case 5:
2288                 unicode  =  (string[0] & 0x0f) << 24;
2289                 unicode += ((string[1] & 0x3f) << 18);
2290                 unicode += ((string[2] & 0x3f) << 12);
2291                 unicode += ((string[3] & 0x3f) << 6);
2292                 unicode +=  (string[4] & 0x3f);
2293                 break;
2294         case 6:
2295                 unicode  =  (string[0] & 0x01) << 30;
2296                 unicode += ((string[1] & 0x3f) << 24);
2297                 unicode += ((string[2] & 0x3f) << 18);
2298                 unicode += ((string[3] & 0x3f) << 12);
2299                 unicode += ((string[4] & 0x3f) << 6);
2300                 unicode +=  (string[5] & 0x3f);
2301                 break;
2302         default:
2303                 die("Invalid unicode length");
2304         }
2305
2306         /* Invalid characters could return the special 0xfffd value but NUL
2307          * should be just as good. */
2308         return unicode > 0xffff ? 0 : unicode;
2309 }
2310
2311 /* Calculates how much of string can be shown within the given maximum width
2312  * and sets trimmed parameter to non-zero value if all of string could not be
2313  * shown.
2314  *
2315  * Additionally, adds to coloffset how many many columns to move to align with
2316  * the expected position. Takes into account how multi-byte and double-width
2317  * characters will effect the cursor position.
2318  *
2319  * Returns the number of bytes to output from string to satisfy max_width. */
2320 static size_t
2321 utf8_length(const char *string, size_t max_width, int *coloffset, int *trimmed)
2322 {
2323         const char *start = string;
2324         const char *end = strchr(string, '\0');
2325         size_t mbwidth = 0;
2326         size_t width = 0;
2327
2328         *trimmed = 0;
2329
2330         while (string < end) {
2331                 int c = *(unsigned char *) string;
2332                 unsigned char bytes = utf8_bytes[c];
2333                 size_t ucwidth;
2334                 unsigned long unicode;
2335
2336                 if (string + bytes > end)
2337                         break;
2338
2339                 /* Change representation to figure out whether
2340                  * it is a single- or double-width character. */
2341
2342                 unicode = utf8_to_unicode(string, bytes);
2343                 /* FIXME: Graceful handling of invalid unicode character. */
2344                 if (!unicode)
2345                         break;
2346
2347                 ucwidth = unicode_width(unicode);
2348                 width  += ucwidth;
2349                 if (width > max_width) {
2350                         *trimmed = 1;
2351                         break;
2352                 }
2353
2354                 /* The column offset collects the differences between the
2355                  * number of bytes encoding a character and the number of
2356                  * columns will be used for rendering said character.
2357                  *
2358                  * So if some character A is encoded in 2 bytes, but will be
2359                  * represented on the screen using only 1 byte this will and up
2360                  * adding 1 to the multi-byte column offset.
2361                  *
2362                  * Assumes that no double-width character can be encoding in
2363                  * less than two bytes. */
2364                 if (bytes > ucwidth)
2365                         mbwidth += bytes - ucwidth;
2366
2367                 string  += bytes;
2368         }
2369
2370         *coloffset += mbwidth;
2371
2372         return string - start;
2373 }
2374
2375
2376 /*
2377  * Status management
2378  */
2379
2380 /* Whether or not the curses interface has been initialized. */
2381 static bool cursed = FALSE;
2382
2383 /* The status window is used for polling keystrokes. */
2384 static WINDOW *status_win;
2385
2386 /* Update status and title window. */
2387 static void
2388 report(const char *msg, ...)
2389 {
2390         static bool empty = TRUE;
2391         struct view *view = display[current_view];
2392
2393         if (!empty || *msg) {
2394                 va_list args;
2395
2396                 va_start(args, msg);
2397
2398                 werase(status_win);
2399                 wmove(status_win, 0, 0);
2400                 if (*msg) {
2401                         vwprintw(status_win, msg, args);
2402                         empty = FALSE;
2403                 } else {
2404                         empty = TRUE;
2405                 }
2406                 wrefresh(status_win);
2407
2408                 va_end(args);
2409         }
2410
2411         update_view_title(view);
2412         update_display_cursor();
2413 }
2414
2415 /* Controls when nodelay should be in effect when polling user input. */
2416 static void
2417 set_nonblocking_input(bool loading)
2418 {
2419         static unsigned int loading_views;
2420
2421         if ((loading == FALSE && loading_views-- == 1) ||
2422             (loading == TRUE  && loading_views++ == 0))
2423                 nodelay(status_win, loading);
2424 }
2425
2426 static void
2427 init_display(void)
2428 {
2429         int x, y;
2430
2431         /* Initialize the curses library */
2432         if (isatty(STDIN_FILENO)) {
2433                 cursed = !!initscr();
2434         } else {
2435                 /* Leave stdin and stdout alone when acting as a pager. */
2436                 FILE *io = fopen("/dev/tty", "r+");
2437
2438                 cursed = !!newterm(NULL, io, io);
2439         }
2440
2441         if (!cursed)
2442                 die("Failed to initialize curses");
2443
2444         nonl();         /* Tell curses not to do NL->CR/NL on output */
2445         cbreak();       /* Take input chars one at a time, no wait for \n */
2446         noecho();       /* Don't echo input */
2447         leaveok(stdscr, TRUE);
2448
2449         if (has_colors())
2450                 init_colors();
2451
2452         getmaxyx(stdscr, y, x);
2453         status_win = newwin(1, 0, y - 1, 0);
2454         if (!status_win)
2455                 die("Failed to create status window");
2456
2457         /* Enable keyboard mapping */
2458         keypad(status_win, TRUE);
2459         wbkgdset(status_win, get_line_attr(LINE_STATUS));
2460 }
2461
2462
2463 /*
2464  * Repository references
2465  */
2466
2467 static struct ref *refs;
2468 static size_t refs_size;
2469
2470 /* Id <-> ref store */
2471 static struct ref ***id_refs;
2472 static size_t id_refs_size;
2473
2474 static struct ref **
2475 get_refs(char *id)
2476 {
2477         struct ref ***tmp_id_refs;
2478         struct ref **ref_list = NULL;
2479         size_t ref_list_size = 0;
2480         size_t i;
2481
2482         for (i = 0; i < id_refs_size; i++)
2483                 if (!strcmp(id, id_refs[i][0]->id))
2484                         return id_refs[i];
2485
2486         tmp_id_refs = realloc(id_refs, (id_refs_size + 1) * sizeof(*id_refs));
2487         if (!tmp_id_refs)
2488                 return NULL;
2489
2490         id_refs = tmp_id_refs;
2491
2492         for (i = 0; i < refs_size; i++) {
2493                 struct ref **tmp;
2494
2495                 if (strcmp(id, refs[i].id))
2496                         continue;
2497
2498                 tmp = realloc(ref_list, (ref_list_size + 1) * sizeof(*ref_list));
2499                 if (!tmp) {
2500                         if (ref_list)
2501                                 free(ref_list);
2502                         return NULL;
2503                 }
2504
2505                 ref_list = tmp;
2506                 if (ref_list_size > 0)
2507                         ref_list[ref_list_size - 1]->next = 1;
2508                 ref_list[ref_list_size] = &refs[i];
2509
2510                 /* XXX: The properties of the commit chains ensures that we can
2511                  * safely modify the shared ref. The repo references will
2512                  * always be similar for the same id. */
2513                 ref_list[ref_list_size]->next = 0;
2514                 ref_list_size++;
2515         }
2516
2517         if (ref_list)
2518                 id_refs[id_refs_size++] = ref_list;
2519
2520         return ref_list;
2521 }
2522
2523 static int
2524 read_ref(char *id, int idlen, char *name, int namelen)
2525 {
2526         struct ref *ref;
2527         bool tag = FALSE;
2528
2529         if (!strncmp(name, "refs/tags/", STRING_SIZE("refs/tags/"))) {
2530                 /* Commits referenced by tags has "^{}" appended. */
2531                 if (name[namelen - 1] != '}')
2532                         return OK;
2533
2534                 while (namelen > 0 && name[namelen] != '^')
2535                         namelen--;
2536
2537                 tag = TRUE;
2538                 namelen -= STRING_SIZE("refs/tags/");
2539                 name    += STRING_SIZE("refs/tags/");
2540
2541         } else if (!strncmp(name, "refs/heads/", STRING_SIZE("refs/heads/"))) {
2542                 namelen -= STRING_SIZE("refs/heads/");
2543                 name    += STRING_SIZE("refs/heads/");
2544
2545         } else if (!strcmp(name, "HEAD")) {
2546                 return OK;
2547         }
2548
2549         refs = realloc(refs, sizeof(*refs) * (refs_size + 1));
2550         if (!refs)
2551                 return ERR;
2552
2553         ref = &refs[refs_size++];
2554         ref->name = malloc(namelen + 1);
2555         if (!ref->name)
2556                 return ERR;
2557
2558         strncpy(ref->name, name, namelen);
2559         ref->name[namelen] = 0;
2560         ref->tag = tag;
2561         string_copy(ref->id, id);
2562
2563         return OK;
2564 }
2565
2566 static int
2567 load_refs(void)
2568 {
2569         const char *cmd_env = getenv("TIG_LS_REMOTE");
2570         const char *cmd = cmd_env && *cmd_env ? cmd_env : TIG_LS_REMOTE;
2571
2572         return read_properties(popen(cmd, "r"), "\t", read_ref);
2573 }
2574
2575 static int
2576 read_repo_config_option(char *name, int namelen, char *value, int valuelen)
2577 {
2578         if (!strcmp(name, "i18n.commitencoding"))
2579                 string_copy(opt_encoding, value);
2580
2581         return OK;
2582 }
2583
2584 static int
2585 load_repo_config(void)
2586 {
2587         return read_properties(popen("git repo-config --list", "r"),
2588                                "=", read_repo_config_option);
2589 }
2590
2591 static int
2592 read_properties(FILE *pipe, const char *separators,
2593                 int (*read_property)(char *, int, char *, int))
2594 {
2595         char buffer[BUFSIZ];
2596         char *name;
2597         int state = OK;
2598
2599         if (!pipe)
2600                 return ERR;
2601
2602         while (state == OK && (name = fgets(buffer, sizeof(buffer), pipe))) {
2603                 char *value;
2604                 size_t namelen;
2605                 size_t valuelen;
2606
2607                 name = chomp_string(name);
2608                 namelen = strcspn(name, separators);
2609
2610                 if (name[namelen]) {
2611                         name[namelen] = 0;
2612                         value = chomp_string(name + namelen + 1);
2613                         valuelen = strlen(value);
2614
2615                 } else {
2616                         value = "";
2617                         valuelen = 0;
2618                 }
2619
2620                 state = read_property(name, namelen, value, valuelen);
2621         }
2622
2623         if (state != ERR && ferror(pipe))
2624                 state = ERR;
2625
2626         pclose(pipe);
2627
2628         return state;
2629 }
2630
2631
2632 /*
2633  * Main
2634  */
2635
2636 static void __NORETURN
2637 quit(int sig)
2638 {
2639         /* XXX: Restore tty modes and let the OS cleanup the rest! */
2640         if (cursed)
2641                 endwin();
2642         exit(0);
2643 }
2644
2645 static void __NORETURN
2646 die(const char *err, ...)
2647 {
2648         va_list args;
2649
2650         endwin();
2651
2652         va_start(args, err);
2653         fputs("tig: ", stderr);
2654         vfprintf(stderr, err, args);
2655         fputs("\n", stderr);
2656         va_end(args);
2657
2658         exit(1);
2659 }
2660
2661 int
2662 main(int argc, char *argv[])
2663 {
2664         struct view *view;
2665         enum request request;
2666         size_t i;
2667
2668         signal(SIGINT, quit);
2669
2670         if (load_options() == ERR)
2671                 die("Failed to load user config.");
2672
2673         /* Load the repo config file so options can be overwritten from
2674          * the command line.  */
2675         if (load_repo_config() == ERR)
2676                 die("Failed to load repo config.");
2677
2678         if (!parse_options(argc, argv))
2679                 return 0;
2680
2681         if (load_refs() == ERR)
2682                 die("Failed to load refs.");
2683
2684         /* Require a git repository unless when running in pager mode. */
2685         if (refs_size == 0 && opt_request != REQ_VIEW_PAGER)
2686                 die("Not a git repository");
2687
2688         for (i = 0; i < ARRAY_SIZE(views) && (view = &views[i]); i++)
2689                 view->cmd_env = getenv(view->cmd_env);
2690
2691         request = opt_request;
2692
2693         init_display();
2694
2695         while (view_driver(display[current_view], request)) {
2696                 int key;
2697                 int i;
2698
2699                 foreach_view (view, i)
2700                         update_view(view);
2701
2702                 /* Refresh, accept single keystroke of input */
2703                 key = wgetch(status_win);
2704                 request = get_request(key);
2705
2706                 /* Some low-level request handling. This keeps access to
2707                  * status_win restricted. */
2708                 switch (request) {
2709                 case REQ_PROMPT:
2710                         report(":");
2711                         /* Temporarily switch to line-oriented and echoed
2712                          * input. */
2713                         nocbreak();
2714                         echo();
2715
2716                         if (wgetnstr(status_win, opt_cmd + 4, sizeof(opt_cmd) - 4) == OK) {
2717                                 memcpy(opt_cmd, "git ", 4);
2718                                 opt_request = REQ_VIEW_PAGER;
2719                         } else {
2720                                 report("Prompt interrupted by loading view, "
2721                                        "press 'z' to stop loading views");
2722                                 request = REQ_SCREEN_UPDATE;
2723                         }
2724
2725                         noecho();
2726                         cbreak();
2727                         break;
2728
2729                 case REQ_SCREEN_RESIZE:
2730                 {
2731                         int height, width;
2732
2733                         getmaxyx(stdscr, height, width);
2734
2735                         /* Resize the status view and let the view driver take
2736                          * care of resizing the displayed views. */
2737                         wresize(status_win, 1, width);
2738                         mvwin(status_win, height - 1, 0);
2739                         wrefresh(status_win);
2740                         break;
2741                 }
2742                 default:
2743                         break;
2744                 }
2745         }
2746
2747         quit(0);
2748
2749         return 0;
2750 }