color.c 8.87 KB
Newer Older
1
#include "cache.h"
2
#include "config.h"
3
#include "color.h"
4

5
static int git_use_color_default = GIT_COLOR_AUTO;
6
int color_stdout_is_tty = -1;
7

8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
/*
 * The list of available column colors.
 */
const char *column_colors_ansi[] = {
	GIT_COLOR_RED,
	GIT_COLOR_GREEN,
	GIT_COLOR_YELLOW,
	GIT_COLOR_BLUE,
	GIT_COLOR_MAGENTA,
	GIT_COLOR_CYAN,
	GIT_COLOR_BOLD_RED,
	GIT_COLOR_BOLD_GREEN,
	GIT_COLOR_BOLD_YELLOW,
	GIT_COLOR_BOLD_BLUE,
	GIT_COLOR_BOLD_MAGENTA,
	GIT_COLOR_BOLD_CYAN,
	GIT_COLOR_RESET,
};

/* Ignore the RESET at the end when giving the size */
const int column_colors_ansi_max = ARRAY_SIZE(column_colors_ansi) - 1;

30 31 32 33 34 35
/* An individual foreground or background color. */
struct color {
	enum {
		COLOR_UNSPECIFIED = 0,
		COLOR_NORMAL,
		COLOR_ANSI, /* basic 0-7 ANSI colors */
36 37
		COLOR_256,
		COLOR_RGB
38 39 40
	} type;
	/* The numeric value for ANSI and 256-color modes */
	unsigned char value;
41 42
	/* 24-bit RGB color values */
	unsigned char red, green, blue;
43 44 45 46 47 48 49
};

/*
 * "word" is a buffer of length "len"; does it match the NUL-terminated
 * "match" exactly?
 */
static int match_word(const char *word, int len, const char *match)
50
{
51 52 53
	return !strncasecmp(word, match, len) && !match[len];
}

54 55 56 57 58 59 60 61 62 63
static int get_hex_color(const char *in, unsigned char *out)
{
	unsigned int val;
	val = (hexval(in[0]) << 4) | hexval(in[1]);
	if (val & ~0xff)
		return -1;
	*out = val;
	return 0;
}

64 65 66
static int parse_color(struct color *out, const char *name, int len)
{
	/* Positions in array must match ANSI color codes */
67
	static const char * const color_names[] = {
68
		"black", "red", "green", "yellow",
69 70 71 72
		"blue", "magenta", "cyan", "white"
	};
	char *end;
	int i;
73 74 75 76 77 78 79 80
	long val;

	/* First try the special word "normal"... */
	if (match_word(name, len, "normal")) {
		out->type = COLOR_NORMAL;
		return 0;
	}

81 82 83 84 85 86 87 88 89 90
	/* Try a 24-bit RGB value */
	if (len == 7 && name[0] == '#') {
		if (!get_hex_color(name + 1, &out->red) &&
		    !get_hex_color(name + 3, &out->green) &&
		    !get_hex_color(name + 5, &out->blue)) {
			out->type = COLOR_RGB;
			return 0;
		}
	}

91
	/* Then pick from our human-readable color names... */
92
	for (i = 0; i < ARRAY_SIZE(color_names); i++) {
93 94 95 96 97
		if (match_word(name, len, color_names[i])) {
			out->type = COLOR_ANSI;
			out->value = i;
			return 0;
		}
98
	}
99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115

	/* And finally try a literal 256-color-mode number */
	val = strtol(name, &end, 10);
	if (end - name == len) {
		/*
		 * Allow "-1" as an alias for "normal", but other negative
		 * numbers are bogus.
		 */
		if (val < -1)
			; /* fall through to error */
		else if (val < 0) {
			out->type = COLOR_NORMAL;
			return 0;
		/* Rewrite low numbers as more-portable standard colors. */
		} else if (val < 8) {
			out->type = COLOR_ANSI;
			out->value = val;
116
			return 0;
117 118 119 120 121 122 123 124
		} else if (val < 256) {
			out->type = COLOR_256;
			out->value = val;
			return 0;
		}
	}

	return -1;
125 126
}

Jeff King's avatar
Jeff King committed
127
static int parse_attr(const char *name, size_t len)
128
{
Jeff King's avatar
Jeff King committed
129 130 131 132 133 134 135 136
	static const struct {
		const char *name;
		size_t len;
		int val, neg;
	} attrs[] = {
#define ATTR(x, val, neg) { (x), sizeof(x)-1, (val), (neg) }
		ATTR("bold",      1, 22),
		ATTR("dim",       2, 22),
137
		ATTR("italic",    3, 23),
Jeff King's avatar
Jeff King committed
138 139
		ATTR("ul",        4, 24),
		ATTR("blink",     5, 25),
140 141
		ATTR("reverse",   7, 27),
		ATTR("strike",    9, 29)
Jeff King's avatar
Jeff King committed
142
#undef ATTR
143
	};
Jeff King's avatar
Jeff King committed
144
	int negate = 0;
145
	int i;
Jeff King's avatar
Jeff King committed
146

147 148
	if (skip_prefix_mem(name, len, "no", &name, &len)) {
		skip_prefix_mem(name, len, "-", &name, &len);
Jeff King's avatar
Jeff King committed
149
		negate = 1;
150
	}
Jeff King's avatar
Jeff King committed
151 152 153 154

	for (i = 0; i < ARRAY_SIZE(attrs); i++) {
		if (attrs[i].len == len && !memcmp(attrs[i].name, name, len))
			return negate ? attrs[i].neg : attrs[i].val;
155 156 157 158
	}
	return -1;
}

159
int color_parse(const char *value, char *dst)
René Scharfe's avatar
René Scharfe committed
160
{
161
	return color_parse_mem(value, strlen(value), dst);
René Scharfe's avatar
René Scharfe committed
162 163
}

164 165 166 167 168
/*
 * Write the ANSI color codes for "c" to "out"; the string should
 * already have the ANSI escape code in it. "out" should have enough
 * space in it to fit any color.
 */
169
static char *color_output(char *out, int len, const struct color *c, char type)
170 171 172 173 174 175
{
	switch (c->type) {
	case COLOR_UNSPECIFIED:
	case COLOR_NORMAL:
		break;
	case COLOR_ANSI:
176
		if (len < 2)
177
			BUG("color parsing ran out of space");
178 179 180 181
		*out++ = type;
		*out++ = '0' + c->value;
		break;
	case COLOR_256:
182
		out += xsnprintf(out, len, "%c8;5;%d", type, c->value);
183
		break;
184
	case COLOR_RGB:
185 186
		out += xsnprintf(out, len, "%c8;2;%d;%d;%d", type,
				 c->red, c->green, c->blue);
187
		break;
188 189 190 191 192 193 194 195 196
	}
	return out;
}

static int color_empty(const struct color *c)
{
	return c->type <= COLOR_NORMAL;
}

197
int color_parse_mem(const char *value, int value_len, char *dst)
198 199
{
	const char *ptr = value;
René Scharfe's avatar
René Scharfe committed
200
	int len = value_len;
201
	char *end = dst + COLOR_MAXLEN;
202
	unsigned int attr = 0;
203 204
	struct color fg = { COLOR_UNSPECIFIED };
	struct color bg = { COLOR_UNSPECIFIED };
205

206 207 208 209 210
	while (len > 0 && isspace(*ptr)) {
		ptr++;
		len--;
	}

211 212 213 214
	if (!len) {
		dst[0] = '\0';
		return 0;
	}
215

216
	if (!strncasecmp(ptr, "reset", len)) {
217
		xsnprintf(dst, end - dst, GIT_COLOR_RESET);
218
		return 0;
219 220
	}

221
	/* [fg [bg]] [attr]... */
René Scharfe's avatar
René Scharfe committed
222
	while (len > 0) {
223
		const char *word = ptr;
224
		struct color c = { COLOR_UNSPECIFIED };
René Scharfe's avatar
René Scharfe committed
225
		int val, wordlen = 0;
226

René Scharfe's avatar
René Scharfe committed
227 228 229 230
		while (len > 0 && !isspace(word[wordlen])) {
			wordlen++;
			len--;
		}
231

René Scharfe's avatar
René Scharfe committed
232 233
		ptr = word + wordlen;
		while (len > 0 && isspace(*ptr)) {
234
			ptr++;
René Scharfe's avatar
René Scharfe committed
235 236
			len--;
		}
237

238 239 240
		if (!parse_color(&c, word, wordlen)) {
			if (fg.type == COLOR_UNSPECIFIED) {
				fg = c;
241 242
				continue;
			}
243 244
			if (bg.type == COLOR_UNSPECIFIED) {
				bg = c;
245 246 247 248
				continue;
			}
			goto bad;
		}
René Scharfe's avatar
René Scharfe committed
249
		val = parse_attr(word, wordlen);
250 251 252
		if (0 <= val)
			attr |= (1 << val);
		else
253 254 255
			goto bad;
	}

256 257 258
#undef OUT
#define OUT(x) do { \
	if (dst == end) \
259
		BUG("color parsing ran out of space"); \
260 261 262
	*dst++ = (x); \
} while(0)

263
	if (attr || !color_empty(&fg) || !color_empty(&bg)) {
264
		int sep = 0;
265
		int i;
266

267 268
		OUT('\033');
		OUT('[');
269 270 271 272 273 274 275

		for (i = 0; attr; i++) {
			unsigned bit = (1 << i);
			if (!(attr & bit))
				continue;
			attr &= ~bit;
			if (sep++)
276 277
				OUT(';');
			dst += xsnprintf(dst, end - dst, "%d", i);
278
		}
279
		if (!color_empty(&fg)) {
280
			if (sep++)
281
				OUT(';');
282
			/* foreground colors are all in the 3x range */
283
			dst = color_output(dst, end - dst, &fg, '3');
284
		}
285
		if (!color_empty(&bg)) {
286
			if (sep++)
287
				OUT(';');
288
			/* background colors are all in the 4x range */
289
			dst = color_output(dst, end - dst, &bg, '4');
290
		}
291
		OUT('m');
292
	}
293
	OUT(0);
294
	return 0;
295
bad:
296
	return error(_("invalid color value: %.*s"), value_len, value);
297
#undef OUT
298 299
}

300
int git_config_colorbool(const char *var, const char *value)
301
{
302 303 304 305
	if (value) {
		if (!strcasecmp(value, "never"))
			return 0;
		if (!strcasecmp(value, "always"))
306
			return 1;
307
		if (!strcasecmp(value, "auto"))
308
			return GIT_COLOR_AUTO;
309
	}
310

311 312 313
	if (!var)
		return -1;

314 315
	/* Missing or explicit false to turn off colorization */
	if (!git_config_bool(var, value))
316
		return 0;
317 318

	/* any normal truth value defaults to 'auto' */
319 320 321
	return GIT_COLOR_AUTO;
}

322
static int check_auto_color(int fd)
323
{
324 325 326 327 328
	static int color_stderr_is_tty = -1;
	int *is_tty_p = fd == 1 ? &color_stdout_is_tty : &color_stderr_is_tty;
	if (*is_tty_p < 0)
		*is_tty_p = isatty(fd);
	if (*is_tty_p || (fd == 1 && pager_in_use() && pager_use_color)) {
329
		if (!is_terminal_dumb())
330 331 332
			return 1;
	}
	return 0;
333 334
}

335
int want_color_fd(int fd, int var)
336
{
337 338 339 340 341 342 343
	/*
	 * NEEDSWORK: This function is sometimes used from multiple threads, and
	 * we end up using want_auto racily. That "should not matter" since
	 * we always write the same value, but it's still wrong. This function
	 * is listed in .tsan-suppressions for the time being.
	 */

344
	static int want_auto[3] = { -1, -1, -1 };
345

346 347 348
	if (fd < 1 || fd >= ARRAY_SIZE(want_auto))
		BUG("file descriptor out of range: %d", fd);

349 350 351
	if (var < 0)
		var = git_use_color_default;

352
	if (var == GIT_COLOR_AUTO) {
353 354 355
		if (want_auto[fd] < 0)
			want_auto[fd] = check_auto_color(fd);
		return want_auto[fd];
356
	}
357
	return var;
358 359
}

360
int git_color_config(const char *var, const char *value, void *cb)
361 362
{
	if (!strcmp(var, "color.ui")) {
363
		git_use_color_default = git_config_colorbool(var, value);
364 365 366
		return 0;
	}

367 368 369
	return 0;
}

370 371 372 373 374 375 376 377
int git_color_default_config(const char *var, const char *value, void *cb)
{
	if (git_color_config(var, value, cb) < 0)
		return -1;

	return git_default_config(var, value, cb);
}

378 379 380 381 382 383 384 385 386
void color_print_strbuf(FILE *fp, const char *color, const struct strbuf *sb)
{
	if (*color)
		fprintf(fp, "%s", color);
	fprintf(fp, "%s", sb->buf);
	if (*color)
		fprintf(fp, "%s", GIT_COLOR_RESET);
}

387
static int color_vfprintf(FILE *fp, const char *color, const char *fmt,
388 389 390 391 392
		va_list args, const char *trail)
{
	int r = 0;

	if (*color)
393 394
		r += fprintf(fp, "%s", color);
	r += vfprintf(fp, fmt, args);
395
	if (*color)
396
		r += fprintf(fp, "%s", GIT_COLOR_RESET);
397
	if (trail)
398
		r += fprintf(fp, "%s", trail);
399 400 401
	return r;
}

402
int color_fprintf(FILE *fp, const char *color, const char *fmt, ...)
403 404 405 406
{
	va_list args;
	int r;
	va_start(args, fmt);
407
	r = color_vfprintf(fp, color, fmt, args, NULL);
408 409 410 411
	va_end(args);
	return r;
}

412
int color_fprintf_ln(FILE *fp, const char *color, const char *fmt, ...)
413 414 415 416
{
	va_list args;
	int r;
	va_start(args, fmt);
417
	r = color_vfprintf(fp, color, fmt, args, "\n");
418 419 420
	va_end(args);
	return r;
}
421 422 423 424 425

int color_is_nil(const char *c)
{
	return !strcmp(c, "NIL");
}