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

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

	if (!len)
		return -1;

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