color.c

   1 #include "cache.h"
   2 #include "color.h"
   3
   4 static int git_use_color_default = GIT_COLOR_AUTO;
   5 int color_stdout_is_tty = -1;
   6
   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
  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 */
  35                 COLOR_256
  36         } type;
  37         /* The numeric value for ANSI and 256-color modes */
  38         unsigned char value;
  39 };
  40
  41 /*
  42  * "word" is a buffer of length "len"; does it match the NUL-terminated
  43  * "match" exactly?
  44  */
  45 static int match_word(const char *word, int len, const char *match)
  46 {
  47         return !strncasecmp(word, match, len) && !match[len];
  48 }
  49
  50 static int parse_color(struct color *out, const char *name, int len)
  51 {
  52         /* Positions in array must match ANSI color codes */
  53         static const char * const color_names[] = {
  54                 "black", "red", "green", "yellow",
  55                 "blue", "magenta", "cyan", "white"
  56         };
  57         char *end;
  58         int i;
  59         long val;
  60
  61         /* First try the special word "normal"... */
  62         if (match_word(name, len, "normal")) {
  63                 out->type = COLOR_NORMAL;
  64                 return 0;
  65         }
  66
  67         /* Then pick from our human-readable color names... */
  68         for (i = 0; i < ARRAY_SIZE(color_names); i++) {
  69                 if (match_word(name, len, color_names[i])) {
  70                         out->type = COLOR_ANSI;
  71                         out->value = i;
  72                         return 0;
  73                 }
  74         }
  75
  76         /* And finally try a literal 256-color-mode number */
  77         val = strtol(name, &end, 10);
  78         if (end - name == len) {
  79                 /*
  80                  * Allow "-1" as an alias for "normal", but other negative
  81                  * numbers are bogus.
  82                  */
  83                 if (val < -1)
  84                         ; /* fall through to error */
  85                 else if (val < 0) {
  86                         out->type = COLOR_NORMAL;
  87                         return 0;
  88                 /* Rewrite low numbers as more-portable standard colors. */
  89                 } else if (val < 8) {
  90                         out->type = COLOR_ANSI;
  91                         out->value = val;
  92                 } else if (val < 256) {
  93                         out->type = COLOR_256;
  94                         out->value = val;
  95                         return 0;
  96                 }
  97         }
  98
  99         return -1;
 100 }
 101
 102 static int parse_attr(const char *name, int len)
 103 {
 104         static const int attr_values[] = { 1, 2, 4, 5, 7 };
 105         static const char * const attr_names[] = {
 106                 "bold", "dim", "ul", "blink", "reverse"
 107         };
 108         int i;
 109         for (i = 0; i < ARRAY_SIZE(attr_names); i++) {
 110                 const char *str = attr_names[i];
 111                 if (!strncasecmp(name, str, len) && !str[len])
 112                         return attr_values[i];
 113         }
 114         return -1;
 115 }
 116
 117 int color_parse(const char *value, char *dst)
 118 {
 119         return color_parse_mem(value, strlen(value), dst);
 120 }
 121
 122 #define COLOR_FOREGROUND '3'
 123 #define COLOR_BACKGROUND '4'
 124
 125 /*
 126  * Write the ANSI color codes for "c" to "out"; the string should
 127  * already have the ANSI escape code in it. "out" should have enough
 128  * space in it to fit any color.
 129  */
 130 static char *color_output(char *out, const struct color *c, char type)
 131 {
 132         switch (c->type) {
 133         case COLOR_UNSPECIFIED:
 134         case COLOR_NORMAL:
 135                 break;
 136         case COLOR_ANSI:
 137                 *out++ = type;
 138                 *out++ = '0' + c->value;
 139                 break;
 140         case COLOR_256:
 141                 out += sprintf(out, "%c8;5;%d", type, c->value);
 142                 break;
 143         }
 144         return out;
 145 }
 146
 147 static int color_empty(const struct color *c)
 148 {
 149         return c->type <= COLOR_NORMAL;
 150 }
 151
 152 int color_parse_mem(const char *value, int value_len, char *dst)
 153 {
 154         const char *ptr = value;
 155         int len = value_len;
 156         unsigned int attr = 0;
 157         struct color fg = { COLOR_UNSPECIFIED };
 158         struct color bg = { COLOR_UNSPECIFIED };
 159
 160         if (!strncasecmp(value, "reset", len)) {
 161                 strcpy(dst, GIT_COLOR_RESET);
 162                 return 0;
 163         }
 164
 165         /* [fg [bg]] [attr]... */
 166         while (len > 0) {
 167                 const char *word = ptr;
 168                 struct color c;
 169                 int val, wordlen = 0;
 170
 171                 while (len > 0 && !isspace(word[wordlen])) {
 172                         wordlen++;
 173                         len--;
 174                 }
 175
 176                 ptr = word + wordlen;
 177                 while (len > 0 && isspace(*ptr)) {
 178                         ptr++;
 179                         len--;
 180                 }
 181
 182                 if (!parse_color(&c, word, wordlen)) {
 183                         if (fg.type == COLOR_UNSPECIFIED) {
 184                                 fg = c;
 185                                 continue;
 186                         }
 187                         if (bg.type == COLOR_UNSPECIFIED) {
 188                                 bg = c;
 189                                 continue;
 190                         }
 191                         goto bad;
 192                 }
 193                 val = parse_attr(word, wordlen);
 194                 if (0 <= val)
 195                         attr |= (1 << val);
 196                 else
 197                         goto bad;
 198         }
 199
 200         if (attr || !color_empty(&fg) || !color_empty(&bg)) {
 201                 int sep = 0;
 202                 int i;
 203
 204                 *dst++ = '\033';
 205                 *dst++ = '[';
 206
 207                 for (i = 0; attr; i++) {
 208                         unsigned bit = (1 << i);
 209                         if (!(attr & bit))
 210                                 continue;
 211                         attr &= ~bit;
 212                         if (sep++)
 213                                 *dst++ = ';';
 214                         *dst++ = '0' + i;
 215                 }
 216                 if (!color_empty(&fg)) {
 217                         if (sep++)
 218                                 *dst++ = ';';
 219                         dst = color_output(dst, &fg, COLOR_FOREGROUND);
 220                 }
 221                 if (!color_empty(&bg)) {
 222                         if (sep++)
 223                                 *dst++ = ';';
 224                         dst = color_output(dst, &bg, COLOR_BACKGROUND);
 225                 }
 226                 *dst++ = 'm';
 227         }
 228         *dst = 0;
 229         return 0;
 230 bad:
 231         return error(_("invalid color value: %.*s"), value_len, value);
 232 }
 233
 234 int git_config_colorbool(const char *var, const char *value)
 235 {
 236         if (value) {
 237                 if (!strcasecmp(value, "never"))
 238                         return 0;
 239                 if (!strcasecmp(value, "always"))
 240                         return 1;
 241                 if (!strcasecmp(value, "auto"))
 242                         return GIT_COLOR_AUTO;
 243         }
 244
 245         if (!var)
 246                 return -1;
 247
 248         /* Missing or explicit false to turn off colorization */
 249         if (!git_config_bool(var, value))
 250                 return 0;
 251
 252         /* any normal truth value defaults to 'auto' */
 253         return GIT_COLOR_AUTO;
 254 }
 255
 256 static int check_auto_color(void)
 257 {
 258         if (color_stdout_is_tty < 0)
 259                 color_stdout_is_tty = isatty(1);
 260         if (color_stdout_is_tty || (pager_in_use() && pager_use_color)) {
 261                 char *term = getenv("TERM");
 262                 if (term && strcmp(term, "dumb"))
 263                         return 1;
 264         }
 265         return 0;
 266 }
 267
 268 int want_color(int var)
 269 {
 270         static int want_auto = -1;
 271
 272         if (var < 0)
 273                 var = git_use_color_default;
 274
 275         if (var == GIT_COLOR_AUTO) {
 276                 if (want_auto < 0)
 277                         want_auto = check_auto_color();
 278                 return want_auto;
 279         }
 280         return var;
 281 }
 282
 283 int git_color_config(const char *var, const char *value, void *cb)
 284 {
 285         if (!strcmp(var, "color.ui")) {
 286                 git_use_color_default = git_config_colorbool(var, value);
 287                 return 0;
 288         }
 289
 290         return 0;
 291 }
 292
 293 int git_color_default_config(const char *var, const char *value, void *cb)
 294 {
 295         if (git_color_config(var, value, cb) < 0)
 296                 return -1;
 297
 298         return git_default_config(var, value, cb);
 299 }
 300
 301 void color_print_strbuf(FILE *fp, const char *color, const struct strbuf *sb)
 302 {
 303         if (*color)
 304                 fprintf(fp, "%s", color);
 305         fprintf(fp, "%s", sb->buf);
 306         if (*color)
 307                 fprintf(fp, "%s", GIT_COLOR_RESET);
 308 }
 309
 310 static int color_vfprintf(FILE *fp, const char *color, const char *fmt,
 311                 va_list args, const char *trail)
 312 {
 313         int r = 0;
 314
 315         if (*color)
 316                 r += fprintf(fp, "%s", color);
 317         r += vfprintf(fp, fmt, args);
 318         if (*color)
 319                 r += fprintf(fp, "%s", GIT_COLOR_RESET);
 320         if (trail)
 321                 r += fprintf(fp, "%s", trail);
 322         return r;
 323 }
 324
 325
 326
 327 int color_fprintf(FILE *fp, const char *color, const char *fmt, ...)
 328 {
 329         va_list args;
 330         int r;
 331         va_start(args, fmt);
 332         r = color_vfprintf(fp, color, fmt, args, NULL);
 333         va_end(args);
 334         return r;
 335 }
 336
 337 int color_fprintf_ln(FILE *fp, const char *color, const char *fmt, ...)
 338 {
 339         va_list args;
 340         int r;
 341         va_start(args, fmt);
 342         r = color_vfprintf(fp, color, fmt, args, "\n");
 343         va_end(args);
 344         return r;
 345 }
 346
 347 int color_is_nil(const char *c)
 348 {
 349         return !strcmp(c, "NIL");
 350 }