[thirdparty/git.git] / color.c

#include "cache.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);
}

void color_set(char *dst, const char *color_bytes)
{
	xsnprintf(dst, COLOR_MAXLEN, "%s", color_bytes);
}

/*
 * 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)
			die("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 };

	if (!len)
		return -1;

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

	/* [fg [bg]] [attr]... */
	while (len > 0) {
		const char *word = ptr;
		struct color c;
		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) \
		die("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(void)
{
	if (color_stdout_is_tty < 0)
		color_stdout_is_tty = isatty(1);
	if (color_stdout_is_tty || (pager_in_use() && pager_use_color)) {
		char *term = getenv("TERM");
		if (term && strcmp(term, "dumb"))
			return 1;
	}
	return 0;
}

int want_color(int var)
{
	static int want_auto = -1;

	if (var < 0)
		var = git_use_color_default;

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