color.c: fix color_parse_mem() with value_len == 0
[git/git.git] / color.c
CommitLineData
7c92fe0e 1#include "cache.h"
85023577 2#include "color.h"
7c92fe0e 3
4c7f1819 4static int git_use_color_default = GIT_COLOR_AUTO;
e269eb79 5int color_stdout_is_tty = -1;
6b2f2d98 6
7cd52b5b
DM
7/*
8 * The list of available column colors.
9 */
10const 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 */
27const int column_colors_ansi_max = ARRAY_SIZE(column_colors_ansi) - 1;
28
695d95df
JK
29/* An individual foreground or background color. */
30struct color {
31 enum {
32 COLOR_UNSPECIFIED = 0,
33 COLOR_NORMAL,
34 COLOR_ANSI, /* basic 0-7 ANSI colors */
17a4be26
JK
35 COLOR_256,
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 */
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 */
48static 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
53static 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
63static 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}
125
df8e472c 126static 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),
138 ATTR("blink", 5, 25),
9dc3515c
JK
139 ATTR("reverse", 7, 27),
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)) {
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 158int color_parse(const char *value, char *dst)
2c2dc7c8 159{
f6c5a296 160 return color_parse_mem(value, strlen(value), dst);
2c2dc7c8
RS
161}
162
7ce4fb94
JK
163void 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 173static 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)
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,
190 c->red, c->green, c->blue);
17a4be26 191 break;
695d95df
JK
192 }
193 return out;
194}
195
196static int color_empty(const struct color *c)
197{
198 return c->type <= COLOR_NORMAL;
199}
200
f6c5a296 201int color_parse_mem(const char *value, int value_len, char *dst)
7c92fe0e
JK
202{
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 };
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 }
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;
230 while (len > 0 && isspace(*ptr)) {
7c92fe0e 231 ptr++;
2c2dc7c8
RS
232 len--;
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;
239 }
695d95df
JK
240 if (bg.type == COLOR_UNSPECIFIED) {
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 }
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');
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(';');
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 292bad:
f6c5a296 293 return error(_("invalid color value: %.*s"), value_len, value);
cbc8feea 294#undef OUT
7c92fe0e
JK
295}
296
e269eb79 297int 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 */
312 if (!git_config_bool(var, value))
7c92fe0e 313 return 0;
57f2b842
JH
314
315 /* any normal truth value defaults to 'auto' */
daa0c3d9
JK
316 return GIT_COLOR_AUTO;
317}
318
319static 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}
330
daa0c3d9
JK
331int 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}
345
3e1dd17a 346int git_color_config(const char *var, const char *value, void *cb)
6b2f2d98
MK
347{
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
356int 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}
363
becbdae8
JN
364void 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 373static 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);
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 390int 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 400int 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
410int color_is_nil(const char *c)
411{
412 return !strcmp(c, "NIL");
413}