| 1 | #define DISABLE_SIGN_COMPARE_WARNINGS |
| 2 | |
| 3 | #include "git-compat-util.h" |
| 4 | #include "config.h" |
| 5 | #include "color.h" |
| 6 | #include "editor.h" |
| 7 | #include "gettext.h" |
| 8 | #include "hex-ll.h" |
| 9 | #include "pager.h" |
| 10 | #include "strbuf.h" |
| 11 | |
| 12 | static enum git_colorbool git_use_color_default = GIT_COLOR_AUTO; |
| 13 | int color_stdout_is_tty = -1; |
| 14 | |
| 15 | /* |
| 16 | * The list of available column colors. |
| 17 | */ |
| 18 | const char *column_colors_ansi[] = { |
| 19 | GIT_COLOR_RED, |
| 20 | GIT_COLOR_GREEN, |
| 21 | GIT_COLOR_YELLOW, |
| 22 | GIT_COLOR_BLUE, |
| 23 | GIT_COLOR_MAGENTA, |
| 24 | GIT_COLOR_CYAN, |
| 25 | GIT_COLOR_BOLD_RED, |
| 26 | GIT_COLOR_BOLD_GREEN, |
| 27 | GIT_COLOR_BOLD_YELLOW, |
| 28 | GIT_COLOR_BOLD_BLUE, |
| 29 | GIT_COLOR_BOLD_MAGENTA, |
| 30 | GIT_COLOR_BOLD_CYAN, |
| 31 | GIT_COLOR_RESET, |
| 32 | }; |
| 33 | |
| 34 | enum { |
| 35 | COLOR_BACKGROUND_OFFSET = 10, |
| 36 | COLOR_FOREGROUND_ANSI = 30, |
| 37 | COLOR_FOREGROUND_RGB = 38, |
| 38 | COLOR_FOREGROUND_256 = 38, |
| 39 | COLOR_FOREGROUND_BRIGHT_ANSI = 90, |
| 40 | }; |
| 41 | |
| 42 | /* Ignore the RESET at the end when giving the size */ |
| 43 | const int column_colors_ansi_max = ARRAY_SIZE(column_colors_ansi) - 1; |
| 44 | |
| 45 | /* An individual foreground or background color. */ |
| 46 | struct color { |
| 47 | enum { |
| 48 | COLOR_UNSPECIFIED = 0, |
| 49 | COLOR_NORMAL, |
| 50 | COLOR_ANSI, /* basic 0-7 ANSI colors + "default" (value = 9) */ |
| 51 | COLOR_256, |
| 52 | COLOR_RGB |
| 53 | } type; |
| 54 | /* The numeric value for ANSI and 256-color modes */ |
| 55 | unsigned char value; |
| 56 | /* 24-bit RGB color values */ |
| 57 | unsigned char red, green, blue; |
| 58 | }; |
| 59 | |
| 60 | /* |
| 61 | * "word" is a buffer of length "len"; does it match the NUL-terminated |
| 62 | * "match" exactly? |
| 63 | */ |
| 64 | static int match_word(const char *word, int len, const char *match) |
| 65 | { |
| 66 | return !strncasecmp(word, match, len) && !match[len]; |
| 67 | } |
| 68 | |
| 69 | static int get_hex_color(const char **inp, int width, unsigned char *out) |
| 70 | { |
| 71 | const char *in = *inp; |
| 72 | unsigned int val; |
| 73 | |
| 74 | assert(width == 1 || width == 2); |
| 75 | val = (hexval(in[0]) << 4) | hexval(in[width - 1]); |
| 76 | if (val & ~0xff) |
| 77 | return -1; |
| 78 | *inp += width; |
| 79 | *out = val; |
| 80 | return 0; |
| 81 | } |
| 82 | |
| 83 | /* |
| 84 | * If an ANSI color is recognized in "name", fill "out" and return 0. |
| 85 | * Otherwise, leave out unchanged and return -1. |
| 86 | */ |
| 87 | static int parse_ansi_color(struct color *out, const char *name, int len) |
| 88 | { |
| 89 | /* Positions in array must match ANSI color codes */ |
| 90 | static const char * const color_names[] = { |
| 91 | "black", "red", "green", "yellow", |
| 92 | "blue", "magenta", "cyan", "white" |
| 93 | }; |
| 94 | int i; |
| 95 | int color_offset = COLOR_FOREGROUND_ANSI; |
| 96 | |
| 97 | if (match_word(name, len, "default")) { |
| 98 | /* |
| 99 | * Restores to the terminal's default color, which may not be |
| 100 | * the same as explicitly setting "white" or "black". |
| 101 | * |
| 102 | * ECMA-48 - Control Functions \ |
| 103 | * for Coded Character Sets, 5th edition (June 1991): |
| 104 | * > 39 default display colour (implementation-defined) |
| 105 | * > 49 default background colour (implementation-defined) |
| 106 | * |
| 107 | * Although not supported /everywhere/--according to terminfo, |
| 108 | * some terminals define "op" (original pair) as a blunt |
| 109 | * "set to white on black", or even "send full SGR reset"-- |
| 110 | * it's standard and well-supported enough that if a user |
| 111 | * asks for it in their config this will do the right thing. |
| 112 | */ |
| 113 | out->type = COLOR_ANSI; |
| 114 | out->value = 9 + color_offset; |
| 115 | return 0; |
| 116 | } |
| 117 | |
| 118 | if (strncasecmp(name, "bright", 6) == 0) { |
| 119 | color_offset = COLOR_FOREGROUND_BRIGHT_ANSI; |
| 120 | name += 6; |
| 121 | len -= 6; |
| 122 | } |
| 123 | for (i = 0; i < ARRAY_SIZE(color_names); i++) { |
| 124 | if (match_word(name, len, color_names[i])) { |
| 125 | out->type = COLOR_ANSI; |
| 126 | out->value = i + color_offset; |
| 127 | return 0; |
| 128 | } |
| 129 | } |
| 130 | return -1; |
| 131 | } |
| 132 | |
| 133 | static int parse_color(struct color *out, const char *name, int len) |
| 134 | { |
| 135 | char *end; |
| 136 | long val; |
| 137 | |
| 138 | /* First try the special word "normal"... */ |
| 139 | if (match_word(name, len, "normal")) { |
| 140 | out->type = COLOR_NORMAL; |
| 141 | return 0; |
| 142 | } |
| 143 | |
| 144 | /* Try a 24- or 12-bit RGB value prefixed with '#' */ |
| 145 | if ((len == 7 || len == 4) && name[0] == '#') { |
| 146 | int width_per_color = (len == 7) ? 2 : 1; |
| 147 | const char *color = name + 1; |
| 148 | |
| 149 | if (!get_hex_color(&color, width_per_color, &out->red) && |
| 150 | !get_hex_color(&color, width_per_color, &out->green) && |
| 151 | !get_hex_color(&color, width_per_color, &out->blue)) { |
| 152 | out->type = COLOR_RGB; |
| 153 | return 0; |
| 154 | } |
| 155 | } |
| 156 | |
| 157 | /* Then pick from our human-readable color names... */ |
| 158 | if (parse_ansi_color(out, name, len) == 0) { |
| 159 | return 0; |
| 160 | } |
| 161 | |
| 162 | /* And finally try a literal 256-color-mode number */ |
| 163 | val = strtol(name, &end, 10); |
| 164 | if (end - name == len) { |
| 165 | /* |
| 166 | * Allow "-1" as an alias for "normal", but other negative |
| 167 | * numbers are bogus. |
| 168 | */ |
| 169 | if (val < -1) |
| 170 | ; /* fall through to error */ |
| 171 | else if (val < 0) { |
| 172 | out->type = COLOR_NORMAL; |
| 173 | return 0; |
| 174 | /* Rewrite 0-7 as more-portable standard colors. */ |
| 175 | } else if (val < 8) { |
| 176 | out->type = COLOR_ANSI; |
| 177 | out->value = val + COLOR_FOREGROUND_ANSI; |
| 178 | return 0; |
| 179 | /* Rewrite 8-15 as more-portable aixterm colors. */ |
| 180 | } else if (val < 16) { |
| 181 | out->type = COLOR_ANSI; |
| 182 | out->value = val - 8 + COLOR_FOREGROUND_BRIGHT_ANSI; |
| 183 | return 0; |
| 184 | } else if (val < 256) { |
| 185 | out->type = COLOR_256; |
| 186 | out->value = val; |
| 187 | return 0; |
| 188 | } |
| 189 | } |
| 190 | |
| 191 | return -1; |
| 192 | } |
| 193 | |
| 194 | static int parse_attr(const char *name, size_t len) |
| 195 | { |
| 196 | static const struct { |
| 197 | const char *name; |
| 198 | size_t len; |
| 199 | int val, neg; |
| 200 | } attrs[] = { |
| 201 | #define ATTR(x, val, neg) { (x), sizeof(x)-1, (val), (neg) } |
| 202 | ATTR("bold", 1, 22), |
| 203 | ATTR("dim", 2, 22), |
| 204 | ATTR("italic", 3, 23), |
| 205 | ATTR("ul", 4, 24), |
| 206 | ATTR("blink", 5, 25), |
| 207 | ATTR("reverse", 7, 27), |
| 208 | ATTR("strike", 9, 29) |
| 209 | #undef ATTR |
| 210 | }; |
| 211 | int negate = 0; |
| 212 | int i; |
| 213 | |
| 214 | if (skip_prefix_mem(name, len, "no", &name, &len)) { |
| 215 | skip_prefix_mem(name, len, "-", &name, &len); |
| 216 | negate = 1; |
| 217 | } |
| 218 | |
| 219 | for (i = 0; i < ARRAY_SIZE(attrs); i++) { |
| 220 | if (attrs[i].len == len && !memcmp(attrs[i].name, name, len)) |
| 221 | return negate ? attrs[i].neg : attrs[i].val; |
| 222 | } |
| 223 | return -1; |
| 224 | } |
| 225 | |
| 226 | /* |
| 227 | * Write the ANSI color codes for "c" to "out"; the string should |
| 228 | * already have the ANSI escape code in it. "out" should have enough |
| 229 | * space in it to fit any color. |
| 230 | */ |
| 231 | static char *color_output(char *out, int len, const struct color *c, int background) |
| 232 | { |
| 233 | int offset = 0; |
| 234 | |
| 235 | if (background) |
| 236 | offset = COLOR_BACKGROUND_OFFSET; |
| 237 | switch (c->type) { |
| 238 | case COLOR_UNSPECIFIED: |
| 239 | case COLOR_NORMAL: |
| 240 | break; |
| 241 | case COLOR_ANSI: |
| 242 | out += xsnprintf(out, len, "%d", c->value + offset); |
| 243 | break; |
| 244 | case COLOR_256: |
| 245 | out += xsnprintf(out, len, "%d;5;%d", COLOR_FOREGROUND_256 + offset, |
| 246 | c->value); |
| 247 | break; |
| 248 | case COLOR_RGB: |
| 249 | out += xsnprintf(out, len, "%d;2;%d;%d;%d", |
| 250 | COLOR_FOREGROUND_RGB + offset, |
| 251 | c->red, c->green, c->blue); |
| 252 | break; |
| 253 | } |
| 254 | return out; |
| 255 | } |
| 256 | |
| 257 | static int color_empty(const struct color *c) |
| 258 | { |
| 259 | return c->type <= COLOR_NORMAL; |
| 260 | } |
| 261 | |
| 262 | static int color_parse_mem_1(const char *value, int value_len, |
| 263 | char *dst, int quiet) |
| 264 | { |
| 265 | const char *ptr = value; |
| 266 | int len = value_len; |
| 267 | char *end = dst + COLOR_MAXLEN; |
| 268 | unsigned int has_reset = 0; |
| 269 | unsigned int attr = 0; |
| 270 | struct color fg = { COLOR_UNSPECIFIED }; |
| 271 | struct color bg = { COLOR_UNSPECIFIED }; |
| 272 | |
| 273 | while (len > 0 && isspace(*ptr)) { |
| 274 | ptr++; |
| 275 | len--; |
| 276 | } |
| 277 | |
| 278 | if (!len) { |
| 279 | dst[0] = '\0'; |
| 280 | return 0; |
| 281 | } |
| 282 | |
| 283 | /* [reset] [fg [bg]] [attr]... */ |
| 284 | while (len > 0) { |
| 285 | const char *word = ptr; |
| 286 | struct color c = { COLOR_UNSPECIFIED }; |
| 287 | int val, wordlen = 0; |
| 288 | |
| 289 | while (len > 0 && !isspace(word[wordlen])) { |
| 290 | wordlen++; |
| 291 | len--; |
| 292 | } |
| 293 | |
| 294 | ptr = word + wordlen; |
| 295 | while (len > 0 && isspace(*ptr)) { |
| 296 | ptr++; |
| 297 | len--; |
| 298 | } |
| 299 | |
| 300 | if (match_word(word, wordlen, "reset")) { |
| 301 | has_reset = 1; |
| 302 | continue; |
| 303 | } |
| 304 | |
| 305 | if (!parse_color(&c, word, wordlen)) { |
| 306 | if (fg.type == COLOR_UNSPECIFIED) { |
| 307 | fg = c; |
| 308 | continue; |
| 309 | } |
| 310 | if (bg.type == COLOR_UNSPECIFIED) { |
| 311 | bg = c; |
| 312 | continue; |
| 313 | } |
| 314 | goto bad; |
| 315 | } |
| 316 | val = parse_attr(word, wordlen); |
| 317 | if (0 <= val) |
| 318 | attr |= (1 << val); |
| 319 | else |
| 320 | goto bad; |
| 321 | } |
| 322 | |
| 323 | #undef OUT |
| 324 | #define OUT(x) do { \ |
| 325 | if (dst == end) \ |
| 326 | BUG("color parsing ran out of space"); \ |
| 327 | *dst++ = (x); \ |
| 328 | } while(0) |
| 329 | |
| 330 | if (has_reset || attr || !color_empty(&fg) || !color_empty(&bg)) { |
| 331 | int sep = 0; |
| 332 | int i; |
| 333 | |
| 334 | OUT('\033'); |
| 335 | OUT('['); |
| 336 | |
| 337 | if (has_reset) |
| 338 | sep++; |
| 339 | |
| 340 | for (i = 0; attr; i++) { |
| 341 | unsigned bit = (1 << i); |
| 342 | if (!(attr & bit)) |
| 343 | continue; |
| 344 | attr &= ~bit; |
| 345 | if (sep++) |
| 346 | OUT(';'); |
| 347 | dst += xsnprintf(dst, end - dst, "%d", i); |
| 348 | } |
| 349 | if (!color_empty(&fg)) { |
| 350 | if (sep++) |
| 351 | OUT(';'); |
| 352 | dst = color_output(dst, end - dst, &fg, 0); |
| 353 | } |
| 354 | if (!color_empty(&bg)) { |
| 355 | if (sep++) |
| 356 | OUT(';'); |
| 357 | dst = color_output(dst, end - dst, &bg, 1); |
| 358 | } |
| 359 | OUT('m'); |
| 360 | } |
| 361 | OUT(0); |
| 362 | return 0; |
| 363 | bad: |
| 364 | return quiet ? -1 : error(_("invalid color value: %.*s"), value_len, value); |
| 365 | #undef OUT |
| 366 | } |
| 367 | |
| 368 | int color_parse_mem(const char *value, int value_len, char *dst) |
| 369 | { |
| 370 | return color_parse_mem_1(value, value_len, dst, 0); |
| 371 | } |
| 372 | |
| 373 | int color_parse(const char *value, char *dst) |
| 374 | { |
| 375 | return color_parse_mem(value, strlen(value), dst); |
| 376 | } |
| 377 | |
| 378 | int color_parse_quietly(const char *value, char *dst) |
| 379 | { |
| 380 | return color_parse_mem_1(value, strlen(value), dst, 1); |
| 381 | } |
| 382 | |
| 383 | enum git_colorbool git_config_colorbool(const char *var, const char *value) |
| 384 | { |
| 385 | if (value) { |
| 386 | if (!strcasecmp(value, "never")) |
| 387 | return GIT_COLOR_NEVER; |
| 388 | if (!strcasecmp(value, "always")) |
| 389 | return GIT_COLOR_ALWAYS; |
| 390 | if (!strcasecmp(value, "auto")) |
| 391 | return GIT_COLOR_AUTO; |
| 392 | } |
| 393 | |
| 394 | if (!var) |
| 395 | return GIT_COLOR_UNKNOWN; |
| 396 | |
| 397 | /* Missing or explicit false to turn off colorization */ |
| 398 | if (!git_config_bool(var, value)) |
| 399 | return GIT_COLOR_NEVER; |
| 400 | |
| 401 | /* any normal truth value defaults to 'auto' */ |
| 402 | return GIT_COLOR_AUTO; |
| 403 | } |
| 404 | |
| 405 | static bool check_auto_color(int fd) |
| 406 | { |
| 407 | static int color_stderr_is_tty = -1; |
| 408 | int *is_tty_p = fd == 1 ? &color_stdout_is_tty : &color_stderr_is_tty; |
| 409 | if (*is_tty_p < 0) |
| 410 | *is_tty_p = isatty(fd); |
| 411 | if (*is_tty_p || (fd == 1 && pager_in_use() && pager_use_color)) { |
| 412 | if (!is_terminal_dumb()) |
| 413 | return true; |
| 414 | } |
| 415 | return false; |
| 416 | } |
| 417 | |
| 418 | bool want_color_fd(int fd, enum git_colorbool var) |
| 419 | { |
| 420 | /* |
| 421 | * NEEDSWORK: This function is sometimes used from multiple threads, and |
| 422 | * we end up using want_auto racily. That "should not matter" since |
| 423 | * we always write the same value, but it's still wrong. This function |
| 424 | * is listed in .tsan-suppressions for the time being. |
| 425 | */ |
| 426 | |
| 427 | static int want_auto[3] = { -1, -1, -1 }; |
| 428 | |
| 429 | if (fd < 1 || fd >= ARRAY_SIZE(want_auto)) |
| 430 | BUG("file descriptor out of range: %d", fd); |
| 431 | |
| 432 | if (var == GIT_COLOR_UNKNOWN) |
| 433 | var = git_use_color_default; |
| 434 | |
| 435 | if (var == GIT_COLOR_AUTO) { |
| 436 | if (want_auto[fd] < 0) |
| 437 | want_auto[fd] = check_auto_color(fd); |
| 438 | return want_auto[fd]; |
| 439 | } |
| 440 | return var == GIT_COLOR_ALWAYS; |
| 441 | } |
| 442 | |
| 443 | int git_color_config(const char *var, const char *value, void *cb UNUSED) |
| 444 | { |
| 445 | if (!strcmp(var, "color.ui")) { |
| 446 | git_use_color_default = git_config_colorbool(var, value); |
| 447 | return 0; |
| 448 | } |
| 449 | |
| 450 | return 0; |
| 451 | } |
| 452 | |
| 453 | void color_print_strbuf(FILE *fp, const char *color, const struct strbuf *sb) |
| 454 | { |
| 455 | if (*color) |
| 456 | fprintf(fp, "%s", color); |
| 457 | fprintf(fp, "%s", sb->buf); |
| 458 | if (*color) |
| 459 | fprintf(fp, "%s", GIT_COLOR_RESET); |
| 460 | } |
| 461 | |
| 462 | static int color_vfprintf(FILE *fp, const char *color, const char *fmt, |
| 463 | va_list args, const char *trail) |
| 464 | { |
| 465 | int r = 0; |
| 466 | |
| 467 | if (*color) |
| 468 | r += fprintf(fp, "%s", color); |
| 469 | r += vfprintf(fp, fmt, args); |
| 470 | if (*color) |
| 471 | r += fprintf(fp, "%s", GIT_COLOR_RESET); |
| 472 | if (trail) |
| 473 | r += fprintf(fp, "%s", trail); |
| 474 | return r; |
| 475 | } |
| 476 | |
| 477 | int color_fprintf(FILE *fp, const char *color, const char *fmt, ...) |
| 478 | { |
| 479 | va_list args; |
| 480 | int r; |
| 481 | va_start(args, fmt); |
| 482 | r = color_vfprintf(fp, color, fmt, args, NULL); |
| 483 | va_end(args); |
| 484 | return r; |
| 485 | } |
| 486 | |
| 487 | int color_fprintf_ln(FILE *fp, const char *color, const char *fmt, ...) |
| 488 | { |
| 489 | va_list args; |
| 490 | int r; |
| 491 | va_start(args, fmt); |
| 492 | r = color_vfprintf(fp, color, fmt, args, "\n"); |
| 493 | va_end(args); |
| 494 | return r; |
| 495 | } |
| 496 | |
| 497 | int color_is_nil(const char *c) |
| 498 | { |
| 499 | return !strcmp(c, "NIL"); |
| 500 | } |