[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 (!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 = { 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) \
		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
2c2dc7c8	210	if (!strncasecmp(value, "reset", len)) {
cbc8feea	211	xsnprintf(dst, end - dst, GIT_COLOR_RESET);
f6c5a296	212	return 0;
7c92fe0e JK	213	}
7c92fe0e JK	214
8b124135	215	/* [fg [bg]] [attr]... */
2c2dc7c8	216	while (len > 0) {
7c92fe0e	217	const char *word = ptr;
3e1952ed	218	struct color c = { COLOR_UNSPECIFIED };
2c2dc7c8	219	int val, wordlen = 0;
7c92fe0e	220
2c2dc7c8 RS	221	while (len > 0 && !isspace(word[wordlen])) {
	222	wordlen++;
	223	len--;
	224	}
7c92fe0e	225
2c2dc7c8 RS	226	ptr = word + wordlen;
2c2dc7c8 RS	227	while (len > 0 && isspace(*ptr)) {
7c92fe0e	228	ptr++;
2c2dc7c8 RS	229	len--;
2c2dc7c8 RS	230	}
7c92fe0e	231
695d95df JK	232	if (!parse_color(&c, word, wordlen)) {
	233	if (fg.type == COLOR_UNSPECIFIED) {
	234	fg = c;
7c92fe0e JK	235	continue;
7c92fe0e JK	236	}
695d95df JK	237	if (bg.type == COLOR_UNSPECIFIED) {
695d95df JK	238	bg = c;
7c92fe0e JK	239	continue;
	240	}
	241	goto bad;
	242	}
2c2dc7c8	243	val = parse_attr(word, wordlen);
8b124135 JH	244	if (0 <= val)
	245	attr \|= (1 << val);
	246	else
7c92fe0e	247	goto bad;
7c92fe0e JK	248	}
7c92fe0e JK	249
cbc8feea JK	250	#undef OUT
	251	#define OUT(x) do { \
	252	if (dst == end) \
	253	die("BUG: color parsing ran out of space"); \
	254	*dst++ = (x); \
	255	} while(0)
	256
695d95df	257	if (attr \|\| !color_empty(&fg) \|\| !color_empty(&bg)) {
7c92fe0e	258	int sep = 0;
8b124135	259	int i;
7c92fe0e	260
cbc8feea JK	261	OUT('\033');
cbc8feea JK	262	OUT('[');
8b124135 JH	263
	264	for (i = 0; attr; i++) {
	265	unsigned bit = (1 << i);
	266	if (!(attr & bit))
	267	continue;
	268	attr &= ~bit;
	269	if (sep++)
cbc8feea JK	270	OUT(';');
cbc8feea JK	271	dst += xsnprintf(dst, end - dst, "%d", i);
7c92fe0e	272	}
695d95df	273	if (!color_empty(&fg)) {
7c92fe0e	274	if (sep++)
cbc8feea	275	OUT(';');
71b59849	276	/* foreground colors are all in the 3x range */
cbc8feea	277	dst = color_output(dst, end - dst, &fg, '3');
7c92fe0e	278	}
695d95df	279	if (!color_empty(&bg)) {
7c92fe0e	280	if (sep++)
cbc8feea	281	OUT(';');
71b59849	282	/* background colors are all in the 4x range */
cbc8feea	283	dst = color_output(dst, end - dst, &bg, '4');
7c92fe0e	284	}
cbc8feea	285	OUT('m');
7c92fe0e	286	}
cbc8feea	287	OUT(0);
f6c5a296	288	return 0;
7c92fe0e	289	bad:
f6c5a296	290	return error(_("invalid color value: %.*s"), value_len, value);
cbc8feea	291	#undef OUT
7c92fe0e JK	292	}
7c92fe0e JK	293
e269eb79	294	int git_config_colorbool(const char var, const char value)
7c92fe0e	295	{
57f2b842 JH	296	if (value) {
	297	if (!strcasecmp(value, "never"))
	298	return 0;
	299	if (!strcasecmp(value, "always"))
	300	return 1;
	301	if (!strcasecmp(value, "auto"))
daa0c3d9	302	return GIT_COLOR_AUTO;
7c92fe0e	303	}
57f2b842	304
73e9da01 ML	305	if (!var)
	306	return -1;
	307
57f2b842 JH	308	/* Missing or explicit false to turn off colorization */
57f2b842 JH	309	if (!git_config_bool(var, value))
7c92fe0e	310	return 0;
57f2b842 JH	311
57f2b842 JH	312	/* any normal truth value defaults to 'auto' */
daa0c3d9 JK	313	return GIT_COLOR_AUTO;
	314	}
	315
	316	static int check_auto_color(void)
	317	{
e269eb79 JK	318	if (color_stdout_is_tty < 0)
	319	color_stdout_is_tty = isatty(1);
	320	if (color_stdout_is_tty \|\| (pager_in_use() && pager_use_color)) {
57f2b842 JH	321	char *term = getenv("TERM");
	322	if (term && strcmp(term, "dumb"))
	323	return 1;
	324	}
	325	return 0;
7c92fe0e JK	326	}
7c92fe0e JK	327
daa0c3d9 JK	328	int want_color(int var)
	329	{
	330	static int want_auto = -1;
	331
c9bfb953 JK	332	if (var < 0)
	333	var = git_use_color_default;
	334
daa0c3d9 JK	335	if (var == GIT_COLOR_AUTO) {
	336	if (want_auto < 0)
	337	want_auto = check_auto_color();
	338	return want_auto;
	339	}
c9bfb953	340	return var;
daa0c3d9 JK	341	}
daa0c3d9 JK	342
3e1dd17a	343	int git_color_config(const char var, const char value, void *cb)
6b2f2d98 MK	344	{
6b2f2d98 MK	345	if (!strcmp(var, "color.ui")) {
e269eb79	346	git_use_color_default = git_config_colorbool(var, value);
6b2f2d98 MK	347	return 0;
	348	}
	349
3e1dd17a JK	350	return 0;
	351	}
	352
	353	int git_color_default_config(const char var, const char value, void *cb)
	354	{
	355	if (git_color_config(var, value, cb) < 0)
	356	return -1;
	357
ef90d6d4	358	return git_default_config(var, value, cb);
6b2f2d98 MK	359	}
6b2f2d98 MK	360
becbdae8 JN	361	void color_print_strbuf(FILE fp, const char color, const struct strbuf *sb)
	362	{
	363	if (*color)
	364	fprintf(fp, "%s", color);
	365	fprintf(fp, "%s", sb->buf);
	366	if (*color)
	367	fprintf(fp, "%s", GIT_COLOR_RESET);
	368	}
	369
f26a0012	370	static int color_vfprintf(FILE fp, const char color, const char *fmt,
7c92fe0e JK	371	va_list args, const char *trail)
	372	{
	373	int r = 0;
	374
	375	if (*color)
f26a0012 KH	376	r += fprintf(fp, "%s", color);
f26a0012 KH	377	r += vfprintf(fp, fmt, args);
7c92fe0e	378	if (*color)
dc6ebd4c	379	r += fprintf(fp, "%s", GIT_COLOR_RESET);
7c92fe0e	380	if (trail)
f26a0012	381	r += fprintf(fp, "%s", trail);
7c92fe0e JK	382	return r;
	383	}
	384
	385
	386
f26a0012	387	int color_fprintf(FILE fp, const char color, const char *fmt, ...)
7c92fe0e JK	388	{
	389	va_list args;
	390	int r;
	391	va_start(args, fmt);
f26a0012	392	r = color_vfprintf(fp, color, fmt, args, NULL);
7c92fe0e JK	393	va_end(args);
	394	return r;
	395	}
	396
f26a0012	397	int color_fprintf_ln(FILE fp, const char color, const char *fmt, ...)
7c92fe0e JK	398	{
	399	va_list args;
	400	int r;
	401	va_start(args, fmt);
f26a0012	402	r = color_vfprintf(fp, color, fmt, args, "\n");
7c92fe0e JK	403	va_end(args);
	404	return r;
	405	}
148135fc JK	406
	407	int color_is_nil(const char *c)
	408	{
	409	return !strcmp(c, "NIL");
	410	}