[thirdparty/git.git] / color.c

#include "cache.h"
#include "config.h"
#include "color.h"

static int git_use_color_default = GIT_COLOR_AUTO;
int color_stdout_is_tty = -1;

/*
 * 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;

/* An individual foreground or background color. */
struct color {
	enum {
		COLOR_UNSPECIFIED = 0,
		COLOR_NORMAL,
		COLOR_ANSI, /* basic 0-7 ANSI colors */
		COLOR_256,
		COLOR_RGB
	} type;
	/* The numeric value for ANSI and 256-color modes */
	unsigned char value;
	/* 24-bit RGB color values */
	unsigned char red, green, blue;
};

/*
 * "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)
{
	return !strncasecmp(word, match, len) && !match[len];
}

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;
}

static int parse_color(struct color *out, const char *name, int len)
{
	/* Positions in array must match ANSI color codes */
	static const char * const color_names[] = {
		"black", "red", "green", "yellow",
		"blue", "magenta", "cyan", "white"
	};
	char *end;
	int i;
	long val;

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

	/* 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;
		}
	}

	/* Then pick from our human-readable color names... */
	for (i = 0; i < ARRAY_SIZE(color_names); i++) {
		if (match_word(name, len, color_names[i])) {
			out->type = COLOR_ANSI;
			out->value = i;
			return 0;
		}
	}

	/* 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;
			return 0;
		} else if (val < 256) {
			out->type = COLOR_256;
			out->value = val;
			return 0;
		}
	}

	return -1;
}

static int parse_attr(const char *name, size_t len)
{
	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),
		ATTR("italic",    3, 23),
		ATTR("ul",        4, 24),
		ATTR("blink",     5, 25),
		ATTR("reverse",   7, 27),
		ATTR("strike",    9, 29)
#undef ATTR
	};
	int negate = 0;
	int i;

	if (skip_prefix_mem(name, len, "no", &name, &len)) {
		skip_prefix_mem(name, len, "-", &name, &len);
		negate = 1;
	}

	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;
	}
	return -1;
}

int color_parse(const char *value, char *dst)
{
	return color_parse_mem(value, strlen(value), dst);
}

/*
 * 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.
 */
static char *color_output(char *out, int len, const struct color *c, char type)
{
	switch (c->type) {
	case COLOR_UNSPECIFIED:
	case COLOR_NORMAL:
		break;
	case COLOR_ANSI:
		if (len < 2)
			BUG("color parsing ran out of space");
		*out++ = type;
		*out++ = '0' + c->value;
		break;
	case COLOR_256:
		out += xsnprintf(out, len, "%c8;5;%d", type, c->value);
		break;
	case COLOR_RGB:
		out += xsnprintf(out, len, "%c8;2;%d;%d;%d", type,
				 c->red, c->green, c->blue);
		break;
	}
	return out;
}

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

int color_parse_mem(const char *value, int value_len, char *dst)
{
	const char *ptr = value;
	int len = value_len;
	char *end = dst + COLOR_MAXLEN;
	unsigned int attr = 0;
	struct color fg = { COLOR_UNSPECIFIED };
	struct color bg = { COLOR_UNSPECIFIED };

	while (len > 0 && isspace(*ptr)) {
		ptr++;
		len--;
	}

	if (!len) {
		dst[0] = '\0';
		return 0;
	}

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

	/* [fg [bg]] [attr]... */
	while (len > 0) {
		const char *word = ptr;
		struct color c = { COLOR_UNSPECIFIED };
		int val, wordlen = 0;

		while (len > 0 && !isspace(word[wordlen])) {
			wordlen++;
			len--;
		}

		ptr = word + wordlen;
		while (len > 0 && isspace(*ptr)) {
			ptr++;
			len--;
		}

		if (!parse_color(&c, word, wordlen)) {
			if (fg.type == COLOR_UNSPECIFIED) {
				fg = c;
				continue;
			}
			if (bg.type == COLOR_UNSPECIFIED) {
				bg = c;
				continue;
			}
			goto bad;
		}
		val = parse_attr(word, wordlen);
		if (0 <= val)
			attr |= (1 << val);
		else
			goto bad;
	}

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

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

		OUT('\033');
		OUT('[');

		for (i = 0; attr; i++) {
			unsigned bit = (1 << i);
			if (!(attr & bit))
				continue;
			attr &= ~bit;
			if (sep++)
				OUT(';');
			dst += xsnprintf(dst, end - dst, "%d", i);
		}
		if (!color_empty(&fg)) {
			if (sep++)
				OUT(';');
			/* foreground colors are all in the 3x range */
			dst = color_output(dst, end - dst, &fg, '3');
		}
		if (!color_empty(&bg)) {
			if (sep++)
				OUT(';');
			/* background colors are all in the 4x range */
			dst = color_output(dst, end - dst, &bg, '4');
		}
		OUT('m');
	}
	OUT(0);
	return 0;
bad:
	return error(_("invalid color value: %.*s"), value_len, value);
#undef OUT
}

int git_config_colorbool(const char *var, const char *value)
{
	if (value) {
		if (!strcasecmp(value, "never"))
			return 0;
		if (!strcasecmp(value, "always"))
			return 1;
		if (!strcasecmp(value, "auto"))
			return GIT_COLOR_AUTO;
	}

	if (!var)
		return -1;

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

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

static int check_auto_color(int fd)
{
	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)) {
		if (!is_terminal_dumb())
			return 1;
	}
	return 0;
}

int want_color_fd(int fd, int var)
{
	/*
	 * 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.
	 */

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

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

	if (var < 0)
		var = git_use_color_default;

	if (var == GIT_COLOR_AUTO) {
		if (want_auto[fd] < 0)
			want_auto[fd] = check_auto_color(fd);
		return want_auto[fd];
	}
	return var;
}

int git_color_config(const char *var, const char *value, void *cb)
{
	if (!strcmp(var, "color.ui")) {
		git_use_color_default = git_config_colorbool(var, value);
		return 0;
	}

	return 0;
}

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);
}

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);
}

static int color_vfprintf(FILE *fp, const char *color, const char *fmt,
		va_list args, const char *trail)
{
	int r = 0;

	if (*color)
		r += fprintf(fp, "%s", color);
	r += vfprintf(fp, fmt, args);
	if (*color)
		r += fprintf(fp, "%s", GIT_COLOR_RESET);
	if (trail)
		r += fprintf(fp, "%s", trail);
	return r;
}

int color_fprintf(FILE *fp, const char *color, const char *fmt, ...)
{
	va_list args;
	int r;
	va_start(args, fmt);
	r = color_vfprintf(fp, color, fmt, args, NULL);
	va_end(args);
	return r;
}

int color_fprintf_ln(FILE *fp, const char *color, const char *fmt, ...)
{
	va_list args;
	int r;
	va_start(args, fmt);
	r = color_vfprintf(fp, color, fmt, args, "\n");
	va_end(args);
	return r;
}

int color_is_nil(const char *c)
{
	return !strcmp(c, "NIL");
}
Commit	Line	Data
7c92fe0e	1	#include "cache.h"
b2141fc1	2	#include "config.h"
85023577	3	#include "color.h"
7c92fe0e	4
4c7f1819	5	static int git_use_color_default = GIT_COLOR_AUTO;
e269eb79	6	int color_stdout_is_tty = -1;
6b2f2d98	7
7cd52b5b DM	8	/*
	9	* The list of available column colors.
	10	*/
	11	const char *column_colors_ansi[] = {
	12	GIT_COLOR_RED,
	13	GIT_COLOR_GREEN,
	14	GIT_COLOR_YELLOW,
	15	GIT_COLOR_BLUE,
	16	GIT_COLOR_MAGENTA,
	17	GIT_COLOR_CYAN,
	18	GIT_COLOR_BOLD_RED,
	19	GIT_COLOR_BOLD_GREEN,
	20	GIT_COLOR_BOLD_YELLOW,
	21	GIT_COLOR_BOLD_BLUE,
	22	GIT_COLOR_BOLD_MAGENTA,
	23	GIT_COLOR_BOLD_CYAN,
	24	GIT_COLOR_RESET,
	25	};
	26
	27	/* Ignore the RESET at the end when giving the size */
	28	const int column_colors_ansi_max = ARRAY_SIZE(column_colors_ansi) - 1;
	29
695d95df JK	30	/* An individual foreground or background color. */
	31	struct color {
	32	enum {
	33	COLOR_UNSPECIFIED = 0,
	34	COLOR_NORMAL,
	35	COLOR_ANSI, /* basic 0-7 ANSI colors */
17a4be26 JK	36	COLOR_256,
17a4be26 JK	37	COLOR_RGB
695d95df JK	38	} type;
	39	/* The numeric value for ANSI and 256-color modes */
	40	unsigned char value;
17a4be26 JK	41	/* 24-bit RGB color values */
17a4be26 JK	42	unsigned char red, green, blue;
695d95df JK	43	};
	44
	45	/*
	46	* "word" is a buffer of length "len"; does it match the NUL-terminated
	47	* "match" exactly?
	48	*/
	49	static int match_word(const char word, int len, const char match)
7c92fe0e	50	{
695d95df JK	51	return !strncasecmp(word, match, len) && !match[len];
	52	}
	53
17a4be26 JK	54	static int get_hex_color(const char in, unsigned char out)
	55	{
	56	unsigned int val;
	57	val = (hexval(in[0]) << 4) \| hexval(in[1]);
	58	if (val & ~0xff)
	59	return -1;
	60	*out = val;
	61	return 0;
	62	}
	63
695d95df JK	64	static int parse_color(struct color out, const char name, int len)
	65	{
	66	/* Positions in array must match ANSI color codes */
7c92fe0e	67	static const char * const color_names[] = {
695d95df	68	"black", "red", "green", "yellow",
7c92fe0e JK	69	"blue", "magenta", "cyan", "white"
	70	};
	71	char *end;
	72	int i;
695d95df JK	73	long val;
	74
	75	/* First try the special word "normal"... */
	76	if (match_word(name, len, "normal")) {
	77	out->type = COLOR_NORMAL;
	78	return 0;
	79	}
	80
17a4be26 JK	81	/* Try a 24-bit RGB value */
	82	if (len == 7 && name[0] == '#') {
	83	if (!get_hex_color(name + 1, &out->red) &&
	84	!get_hex_color(name + 3, &out->green) &&
	85	!get_hex_color(name + 5, &out->blue)) {
	86	out->type = COLOR_RGB;
	87	return 0;
	88	}
	89	}
	90
695d95df	91	/* Then pick from our human-readable color names... */
7c92fe0e	92	for (i = 0; i < ARRAY_SIZE(color_names); i++) {
695d95df JK	93	if (match_word(name, len, color_names[i])) {
	94	out->type = COLOR_ANSI;
	95	out->value = i;
	96	return 0;
	97	}
7c92fe0e	98	}
695d95df JK	99
	100	/* And finally try a literal 256-color-mode number */
	101	val = strtol(name, &end, 10);
	102	if (end - name == len) {
	103	/*
	104	* Allow "-1" as an alias for "normal", but other negative
	105	* numbers are bogus.
	106	*/
	107	if (val < -1)
	108	; /* fall through to error */
	109	else if (val < 0) {
	110	out->type = COLOR_NORMAL;
	111	return 0;
	112	/* Rewrite low numbers as more-portable standard colors. */
	113	} else if (val < 8) {
	114	out->type = COLOR_ANSI;
	115	out->value = val;
3759d27a	116	return 0;
695d95df JK	117	} else if (val < 256) {
	118	out->type = COLOR_256;
	119	out->value = val;
	120	return 0;
	121	}
	122	}
	123
	124	return -1;
7c92fe0e JK	125	}
7c92fe0e JK	126
df8e472c	127	static int parse_attr(const char *name, size_t len)
7c92fe0e	128	{
df8e472c JK	129	static const struct {
	130	const char *name;
	131	size_t len;
	132	int val, neg;
	133	} attrs[] = {
	134	#define ATTR(x, val, neg) { (x), sizeof(x)-1, (val), (neg) }
	135	ATTR("bold", 1, 22),
	136	ATTR("dim", 2, 22),
54590a0e	137	ATTR("italic", 3, 23),
df8e472c JK	138	ATTR("ul", 4, 24),
df8e472c JK	139	ATTR("blink", 5, 25),
9dc3515c JK	140	ATTR("reverse", 7, 27),
9dc3515c JK	141	ATTR("strike", 9, 29)
df8e472c	142	#undef ATTR
7c92fe0e	143	};
df8e472c	144	int negate = 0;
7c92fe0e	145	int i;
df8e472c	146
5621068f JK	147	if (skip_prefix_mem(name, len, "no", &name, &len)) {
5621068f JK	148	skip_prefix_mem(name, len, "-", &name, &len);
df8e472c	149	negate = 1;
5621068f	150	}
df8e472c JK	151
	152	for (i = 0; i < ARRAY_SIZE(attrs); i++) {
	153	if (attrs[i].len == len && !memcmp(attrs[i].name, name, len))
	154	return negate ? attrs[i].neg : attrs[i].val;
7c92fe0e JK	155	}
	156	return -1;
	157	}
	158
f6c5a296	159	int color_parse(const char value, char dst)
2c2dc7c8	160	{
f6c5a296	161	return color_parse_mem(value, strlen(value), dst);
2c2dc7c8 RS	162	}
2c2dc7c8 RS	163
695d95df JK	164	/*
	165	* Write the ANSI color codes for "c" to "out"; the string should
	166	* already have the ANSI escape code in it. "out" should have enough
	167	* space in it to fit any color.
	168	*/
cbc8feea	169	static char color_output(char out, int len, const struct color *c, char type)
695d95df JK	170	{
	171	switch (c->type) {
	172	case COLOR_UNSPECIFIED:
	173	case COLOR_NORMAL:
	174	break;
	175	case COLOR_ANSI:
cbc8feea	176	if (len < 2)
033abf97	177	BUG("color parsing ran out of space");
695d95df JK	178	*out++ = type;
	179	*out++ = '0' + c->value;
	180	break;
	181	case COLOR_256:
cbc8feea	182	out += xsnprintf(out, len, "%c8;5;%d", type, c->value);
695d95df	183	break;
17a4be26	184	case COLOR_RGB:
cbc8feea JK	185	out += xsnprintf(out, len, "%c8;2;%d;%d;%d", type,
cbc8feea JK	186	c->red, c->green, c->blue);
17a4be26	187	break;
695d95df JK	188	}
	189	return out;
	190	}
	191
	192	static int color_empty(const struct color *c)
	193	{
	194	return c->type <= COLOR_NORMAL;
	195	}
	196
f6c5a296	197	int color_parse_mem(const char value, int value_len, char dst)
7c92fe0e JK	198	{
7c92fe0e JK	199	const char *ptr = value;
2c2dc7c8	200	int len = value_len;
cbc8feea	201	char *end = dst + COLOR_MAXLEN;
8b124135	202	unsigned int attr = 0;
695d95df JK	203	struct color fg = { COLOR_UNSPECIFIED };
695d95df JK	204	struct color bg = { COLOR_UNSPECIFIED };
7c92fe0e	205
bc407565 NTND	206	while (len > 0 && isspace(*ptr)) {
	207	ptr++;
	208	len--;
	209	}
	210
55cccf4b JK	211	if (!len) {
	212	dst[0] = '\0';
	213	return 0;
	214	}
c2f41bf5	215
bc407565	216	if (!strncasecmp(ptr, "reset", len)) {
cbc8feea	217	xsnprintf(dst, end - dst, GIT_COLOR_RESET);
f6c5a296	218	return 0;
7c92fe0e JK	219	}
7c92fe0e JK	220
8b124135	221	/* [fg [bg]] [attr]... */
2c2dc7c8	222	while (len > 0) {
7c92fe0e	223	const char *word = ptr;
3e1952ed	224	struct color c = { COLOR_UNSPECIFIED };
2c2dc7c8	225	int val, wordlen = 0;
7c92fe0e	226
2c2dc7c8 RS	227	while (len > 0 && !isspace(word[wordlen])) {
	228	wordlen++;
	229	len--;
	230	}
7c92fe0e	231
2c2dc7c8 RS	232	ptr = word + wordlen;
2c2dc7c8 RS	233	while (len > 0 && isspace(*ptr)) {
7c92fe0e	234	ptr++;
2c2dc7c8 RS	235	len--;
2c2dc7c8 RS	236	}
7c92fe0e	237
695d95df JK	238	if (!parse_color(&c, word, wordlen)) {
	239	if (fg.type == COLOR_UNSPECIFIED) {
	240	fg = c;
7c92fe0e JK	241	continue;
7c92fe0e JK	242	}
695d95df JK	243	if (bg.type == COLOR_UNSPECIFIED) {
695d95df JK	244	bg = c;
7c92fe0e JK	245	continue;
	246	}
	247	goto bad;
	248	}
2c2dc7c8	249	val = parse_attr(word, wordlen);
8b124135 JH	250	if (0 <= val)
	251	attr \|= (1 << val);
	252	else
7c92fe0e	253	goto bad;
7c92fe0e JK	254	}
7c92fe0e JK	255
cbc8feea JK	256	#undef OUT
	257	#define OUT(x) do { \
	258	if (dst == end) \
033abf97	259	BUG("color parsing ran out of space"); \
cbc8feea JK	260	*dst++ = (x); \
	261	} while(0)
	262
695d95df	263	if (attr \|\| !color_empty(&fg) \|\| !color_empty(&bg)) {
7c92fe0e	264	int sep = 0;
8b124135	265	int i;
7c92fe0e	266
cbc8feea JK	267	OUT('\033');
cbc8feea JK	268	OUT('[');
8b124135 JH	269
	270	for (i = 0; attr; i++) {
	271	unsigned bit = (1 << i);
	272	if (!(attr & bit))
	273	continue;
	274	attr &= ~bit;
	275	if (sep++)
cbc8feea JK	276	OUT(';');
cbc8feea JK	277	dst += xsnprintf(dst, end - dst, "%d", i);
7c92fe0e	278	}
695d95df	279	if (!color_empty(&fg)) {
7c92fe0e	280	if (sep++)
cbc8feea	281	OUT(';');
71b59849	282	/* foreground colors are all in the 3x range */
cbc8feea	283	dst = color_output(dst, end - dst, &fg, '3');
7c92fe0e	284	}
695d95df	285	if (!color_empty(&bg)) {
7c92fe0e	286	if (sep++)
cbc8feea	287	OUT(';');
71b59849	288	/* background colors are all in the 4x range */
cbc8feea	289	dst = color_output(dst, end - dst, &bg, '4');
7c92fe0e	290	}
cbc8feea	291	OUT('m');
7c92fe0e	292	}
cbc8feea	293	OUT(0);
f6c5a296	294	return 0;
7c92fe0e	295	bad:
f6c5a296	296	return error(_("invalid color value: %.*s"), value_len, value);
cbc8feea	297	#undef OUT
7c92fe0e JK	298	}
7c92fe0e JK	299
e269eb79	300	int git_config_colorbool(const char var, const char value)
7c92fe0e	301	{
57f2b842 JH	302	if (value) {
	303	if (!strcasecmp(value, "never"))
	304	return 0;
	305	if (!strcasecmp(value, "always"))
2c1acdf6	306	return 1;
57f2b842	307	if (!strcasecmp(value, "auto"))
daa0c3d9	308	return GIT_COLOR_AUTO;
7c92fe0e	309	}
57f2b842	310
73e9da01 ML	311	if (!var)
	312	return -1;
	313
57f2b842 JH	314	/* Missing or explicit false to turn off colorization */
57f2b842 JH	315	if (!git_config_bool(var, value))
7c92fe0e	316	return 0;
57f2b842 JH	317
57f2b842 JH	318	/* any normal truth value defaults to 'auto' */
daa0c3d9 JK	319	return GIT_COLOR_AUTO;
	320	}
	321
295d949c	322	static int check_auto_color(int fd)
daa0c3d9	323	{
295d949c JS	324	static int color_stderr_is_tty = -1;
	325	int *is_tty_p = fd == 1 ? &color_stdout_is_tty : &color_stderr_is_tty;
	326	if (*is_tty_p < 0)
	327	*is_tty_p = isatty(fd);
	328	if (*is_tty_p \|\| (fd == 1 && pager_in_use() && pager_use_color)) {
a64f213d	329	if (!is_terminal_dumb())
57f2b842 JH	330	return 1;
	331	}
	332	return 0;
7c92fe0e JK	333	}
7c92fe0e JK	334
295d949c	335	int want_color_fd(int fd, int var)
daa0c3d9	336	{
6cdf8a79 MÅ	337	/*
	338	* NEEDSWORK: This function is sometimes used from multiple threads, and
	339	* we end up using want_auto racily. That "should not matter" since
	340	* we always write the same value, but it's still wrong. This function
	341	* is listed in .tsan-suppressions for the time being.
	342	*/
	343
295d949c	344	static int want_auto[3] = { -1, -1, -1 };
daa0c3d9	345
65bb21e7 ES	346	if (fd < 1 \|\| fd >= ARRAY_SIZE(want_auto))
	347	BUG("file descriptor out of range: %d", fd);
	348
c9bfb953 JK	349	if (var < 0)
	350	var = git_use_color_default;
	351
daa0c3d9	352	if (var == GIT_COLOR_AUTO) {
295d949c JS	353	if (want_auto[fd] < 0)
	354	want_auto[fd] = check_auto_color(fd);
	355	return want_auto[fd];
daa0c3d9	356	}
c9bfb953	357	return var;
daa0c3d9 JK	358	}
daa0c3d9 JK	359
3e1dd17a	360	int git_color_config(const char var, const char value, void *cb)
6b2f2d98 MK	361	{
6b2f2d98 MK	362	if (!strcmp(var, "color.ui")) {
e269eb79	363	git_use_color_default = git_config_colorbool(var, value);
6b2f2d98 MK	364	return 0;
	365	}
	366
3e1dd17a JK	367	return 0;
	368	}
	369
33c643bb JK	370	int git_color_default_config(const char var, const char value, void *cb)
	371	{
	372	if (git_color_config(var, value, cb) < 0)
	373	return -1;
	374
	375	return git_default_config(var, value, cb);
	376	}
	377
becbdae8 JN	378	void color_print_strbuf(FILE fp, const char color, const struct strbuf *sb)
	379	{
	380	if (*color)
	381	fprintf(fp, "%s", color);
	382	fprintf(fp, "%s", sb->buf);
	383	if (*color)
	384	fprintf(fp, "%s", GIT_COLOR_RESET);
	385	}
	386
f26a0012	387	static int color_vfprintf(FILE fp, const char color, const char *fmt,
7c92fe0e JK	388	va_list args, const char *trail)
	389	{
	390	int r = 0;
	391
	392	if (*color)
f26a0012 KH	393	r += fprintf(fp, "%s", color);
f26a0012 KH	394	r += vfprintf(fp, fmt, args);
7c92fe0e	395	if (*color)
dc6ebd4c	396	r += fprintf(fp, "%s", GIT_COLOR_RESET);
7c92fe0e	397	if (trail)
f26a0012	398	r += fprintf(fp, "%s", trail);
7c92fe0e JK	399	return r;
	400	}
	401
f26a0012	402	int color_fprintf(FILE fp, const char color, const char *fmt, ...)
7c92fe0e JK	403	{
	404	va_list args;
	405	int r;
	406	va_start(args, fmt);
f26a0012	407	r = color_vfprintf(fp, color, fmt, args, NULL);
7c92fe0e JK	408	va_end(args);
	409	return r;
	410	}
	411
f26a0012	412	int color_fprintf_ln(FILE fp, const char color, const char *fmt, ...)
7c92fe0e JK	413	{
	414	va_list args;
	415	int r;
	416	va_start(args, fmt);
f26a0012	417	r = color_vfprintf(fp, color, fmt, args, "\n");
7c92fe0e JK	418	va_end(args);
	419	return r;
	420	}
148135fc JK	421
	422	int color_is_nil(const char *c)
	423	{
	424	return !strcmp(c, "NIL");
	425	}