2006-09-08 12:03:18 +04:00
|
|
|
#include "cache.h"
|
2006-12-20 01:34:12 +03:00
|
|
|
#include "color.h"
|
2006-09-08 12:03:18 +04:00
|
|
|
|
make color.ui default to 'auto'
Most users seem to like having colors enabled, and colors can help
beginners to understand the output of some commands (e.g. notice
immediately the boundary between commits in the output of "git log").
Many tutorials tell the users to set color.ui=auto as a very first step,
which tend to indicate that color.ui=none is not the recommanded value,
hence should not be the default.
These tutorials would benefit from skipping this step and starting the
real Git manipulations earlier. Other beginners do not know about
color.ui=auto, and may not discover it by themselves, hence live with
black&white outputs while they may have preferred colors.
A few people (e.g. color-blind) prefer having no colors, but they can
easily set color.ui=never for this (and googling "disable colors in git"
already tells them how to do so), but this needs not occupy space in
beginner-oriented documentations.
A transition period with Git emitting a warning when color.ui is unset
would be possible, but the discomfort of having the warning seems
superior to the benefit: users may be surprised by the change, but not
harmed by it.
The default value is changed, and the documentation is reworded to
mention "color.ui=false" first, since the primary use of color.ui after
this change is to disable colors, not to enable it.
Signed-off-by: Matthieu Moy <Matthieu.Moy@imag.fr>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-06-10 18:26:09 +04:00
|
|
|
static int git_use_color_default = GIT_COLOR_AUTO;
|
2011-08-18 09:03:48 +04:00
|
|
|
int color_stdout_is_tty = -1;
|
2008-02-18 10:26:03 +03:00
|
|
|
|
2011-04-05 09:40:23 +04:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
|
parse_color: refactor color storage
When we parse a color name like "red" into its ANSI color
value, we pack the storage into a single int that may take
on many values:
1. If it's "-2", no value has been specified.
2. If it's "-1", the value is "normal" (i.e., no color).
3. If it's 0 through 7, the value is a standard ANSI
color.
4. If it's larger (up to 255), it is a 256-color extended
value.
Given these magic numbers, it is often hard to see what is
going on in the code. Let's refactor this into a struct with
a flag that tells which scheme we are using, along with a
numeric value. This is more verbose, but should hopefully be
simpler to follow. It will also allow us to easily add
support for more schemes, like 24-bit RGB values.
The result is also slightly less efficient to store, but
that's OK; we only store this intermediate state during the
parse, after which we write out the actual ANSI bytes.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 18:17:05 +03:00
|
|
|
/* An individual foreground or background color. */
|
|
|
|
struct color {
|
|
|
|
enum {
|
|
|
|
COLOR_UNSPECIFIED = 0,
|
|
|
|
COLOR_NORMAL,
|
|
|
|
COLOR_ANSI, /* basic 0-7 ANSI colors */
|
2014-11-20 18:25:39 +03:00
|
|
|
COLOR_256,
|
|
|
|
COLOR_RGB
|
parse_color: refactor color storage
When we parse a color name like "red" into its ANSI color
value, we pack the storage into a single int that may take
on many values:
1. If it's "-2", no value has been specified.
2. If it's "-1", the value is "normal" (i.e., no color).
3. If it's 0 through 7, the value is a standard ANSI
color.
4. If it's larger (up to 255), it is a 256-color extended
value.
Given these magic numbers, it is often hard to see what is
going on in the code. Let's refactor this into a struct with
a flag that tells which scheme we are using, along with a
numeric value. This is more verbose, but should hopefully be
simpler to follow. It will also allow us to easily add
support for more schemes, like 24-bit RGB values.
The result is also slightly less efficient to store, but
that's OK; we only store this intermediate state during the
parse, after which we write out the actual ANSI bytes.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 18:17:05 +03:00
|
|
|
} type;
|
|
|
|
/* The numeric value for ANSI and 256-color modes */
|
|
|
|
unsigned char value;
|
2014-11-20 18:25:39 +03:00
|
|
|
/* 24-bit RGB color values */
|
|
|
|
unsigned char red, green, blue;
|
parse_color: refactor color storage
When we parse a color name like "red" into its ANSI color
value, we pack the storage into a single int that may take
on many values:
1. If it's "-2", no value has been specified.
2. If it's "-1", the value is "normal" (i.e., no color).
3. If it's 0 through 7, the value is a standard ANSI
color.
4. If it's larger (up to 255), it is a 256-color extended
value.
Given these magic numbers, it is often hard to see what is
going on in the code. Let's refactor this into a struct with
a flag that tells which scheme we are using, along with a
numeric value. This is more verbose, but should hopefully be
simpler to follow. It will also allow us to easily add
support for more schemes, like 24-bit RGB values.
The result is also slightly less efficient to store, but
that's OK; we only store this intermediate state during the
parse, after which we write out the actual ANSI bytes.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 18:17:05 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* "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)
|
2006-09-08 12:03:18 +04:00
|
|
|
{
|
parse_color: refactor color storage
When we parse a color name like "red" into its ANSI color
value, we pack the storage into a single int that may take
on many values:
1. If it's "-2", no value has been specified.
2. If it's "-1", the value is "normal" (i.e., no color).
3. If it's 0 through 7, the value is a standard ANSI
color.
4. If it's larger (up to 255), it is a 256-color extended
value.
Given these magic numbers, it is often hard to see what is
going on in the code. Let's refactor this into a struct with
a flag that tells which scheme we are using, along with a
numeric value. This is more verbose, but should hopefully be
simpler to follow. It will also allow us to easily add
support for more schemes, like 24-bit RGB values.
The result is also slightly less efficient to store, but
that's OK; we only store this intermediate state during the
parse, after which we write out the actual ANSI bytes.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 18:17:05 +03:00
|
|
|
return !strncasecmp(word, match, len) && !match[len];
|
|
|
|
}
|
|
|
|
|
2014-11-20 18:25:39 +03:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
parse_color: refactor color storage
When we parse a color name like "red" into its ANSI color
value, we pack the storage into a single int that may take
on many values:
1. If it's "-2", no value has been specified.
2. If it's "-1", the value is "normal" (i.e., no color).
3. If it's 0 through 7, the value is a standard ANSI
color.
4. If it's larger (up to 255), it is a 256-color extended
value.
Given these magic numbers, it is often hard to see what is
going on in the code. Let's refactor this into a struct with
a flag that tells which scheme we are using, along with a
numeric value. This is more verbose, but should hopefully be
simpler to follow. It will also allow us to easily add
support for more schemes, like 24-bit RGB values.
The result is also slightly less efficient to store, but
that's OK; we only store this intermediate state during the
parse, after which we write out the actual ANSI bytes.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 18:17:05 +03:00
|
|
|
static int parse_color(struct color *out, const char *name, int len)
|
|
|
|
{
|
|
|
|
/* Positions in array must match ANSI color codes */
|
2006-09-08 12:03:18 +04:00
|
|
|
static const char * const color_names[] = {
|
parse_color: refactor color storage
When we parse a color name like "red" into its ANSI color
value, we pack the storage into a single int that may take
on many values:
1. If it's "-2", no value has been specified.
2. If it's "-1", the value is "normal" (i.e., no color).
3. If it's 0 through 7, the value is a standard ANSI
color.
4. If it's larger (up to 255), it is a 256-color extended
value.
Given these magic numbers, it is often hard to see what is
going on in the code. Let's refactor this into a struct with
a flag that tells which scheme we are using, along with a
numeric value. This is more verbose, but should hopefully be
simpler to follow. It will also allow us to easily add
support for more schemes, like 24-bit RGB values.
The result is also slightly less efficient to store, but
that's OK; we only store this intermediate state during the
parse, after which we write out the actual ANSI bytes.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 18:17:05 +03:00
|
|
|
"black", "red", "green", "yellow",
|
2006-09-08 12:03:18 +04:00
|
|
|
"blue", "magenta", "cyan", "white"
|
|
|
|
};
|
|
|
|
char *end;
|
|
|
|
int i;
|
parse_color: refactor color storage
When we parse a color name like "red" into its ANSI color
value, we pack the storage into a single int that may take
on many values:
1. If it's "-2", no value has been specified.
2. If it's "-1", the value is "normal" (i.e., no color).
3. If it's 0 through 7, the value is a standard ANSI
color.
4. If it's larger (up to 255), it is a 256-color extended
value.
Given these magic numbers, it is often hard to see what is
going on in the code. Let's refactor this into a struct with
a flag that tells which scheme we are using, along with a
numeric value. This is more verbose, but should hopefully be
simpler to follow. It will also allow us to easily add
support for more schemes, like 24-bit RGB values.
The result is also slightly less efficient to store, but
that's OK; we only store this intermediate state during the
parse, after which we write out the actual ANSI bytes.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 18:17:05 +03:00
|
|
|
long val;
|
|
|
|
|
|
|
|
/* First try the special word "normal"... */
|
|
|
|
if (match_word(name, len, "normal")) {
|
|
|
|
out->type = COLOR_NORMAL;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-11-20 18:25:39 +03:00
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
parse_color: refactor color storage
When we parse a color name like "red" into its ANSI color
value, we pack the storage into a single int that may take
on many values:
1. If it's "-2", no value has been specified.
2. If it's "-1", the value is "normal" (i.e., no color).
3. If it's 0 through 7, the value is a standard ANSI
color.
4. If it's larger (up to 255), it is a 256-color extended
value.
Given these magic numbers, it is often hard to see what is
going on in the code. Let's refactor this into a struct with
a flag that tells which scheme we are using, along with a
numeric value. This is more verbose, but should hopefully be
simpler to follow. It will also allow us to easily add
support for more schemes, like 24-bit RGB values.
The result is also slightly less efficient to store, but
that's OK; we only store this intermediate state during the
parse, after which we write out the actual ANSI bytes.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 18:17:05 +03:00
|
|
|
/* Then pick from our human-readable color names... */
|
2006-09-08 12:03:18 +04:00
|
|
|
for (i = 0; i < ARRAY_SIZE(color_names); i++) {
|
parse_color: refactor color storage
When we parse a color name like "red" into its ANSI color
value, we pack the storage into a single int that may take
on many values:
1. If it's "-2", no value has been specified.
2. If it's "-1", the value is "normal" (i.e., no color).
3. If it's 0 through 7, the value is a standard ANSI
color.
4. If it's larger (up to 255), it is a 256-color extended
value.
Given these magic numbers, it is often hard to see what is
going on in the code. Let's refactor this into a struct with
a flag that tells which scheme we are using, along with a
numeric value. This is more verbose, but should hopefully be
simpler to follow. It will also allow us to easily add
support for more schemes, like 24-bit RGB values.
The result is also slightly less efficient to store, but
that's OK; we only store this intermediate state during the
parse, after which we write out the actual ANSI bytes.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 18:17:05 +03:00
|
|
|
if (match_word(name, len, color_names[i])) {
|
|
|
|
out->type = COLOR_ANSI;
|
|
|
|
out->value = i;
|
|
|
|
return 0;
|
|
|
|
}
|
2006-09-08 12:03:18 +04:00
|
|
|
}
|
parse_color: refactor color storage
When we parse a color name like "red" into its ANSI color
value, we pack the storage into a single int that may take
on many values:
1. If it's "-2", no value has been specified.
2. If it's "-1", the value is "normal" (i.e., no color).
3. If it's 0 through 7, the value is a standard ANSI
color.
4. If it's larger (up to 255), it is a 256-color extended
value.
Given these magic numbers, it is often hard to see what is
going on in the code. Let's refactor this into a struct with
a flag that tells which scheme we are using, along with a
numeric value. This is more verbose, but should hopefully be
simpler to follow. It will also allow us to easily add
support for more schemes, like 24-bit RGB values.
The result is also slightly less efficient to store, but
that's OK; we only store this intermediate state during the
parse, after which we write out the actual ANSI bytes.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 18:17:05 +03:00
|
|
|
|
|
|
|
/* 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;
|
|
|
|
} else if (val < 256) {
|
|
|
|
out->type = COLOR_256;
|
|
|
|
out->value = val;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
2006-09-08 12:03:18 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static int parse_attr(const char *name, int len)
|
|
|
|
{
|
|
|
|
static const int attr_values[] = { 1, 2, 4, 5, 7 };
|
|
|
|
static const char * const attr_names[] = {
|
|
|
|
"bold", "dim", "ul", "blink", "reverse"
|
|
|
|
};
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(attr_names); i++) {
|
|
|
|
const char *str = attr_names[i];
|
|
|
|
if (!strncasecmp(name, str, len) && !str[len])
|
|
|
|
return attr_values[i];
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2014-10-07 23:33:09 +04:00
|
|
|
int color_parse(const char *value, char *dst)
|
2009-01-20 07:30:30 +03:00
|
|
|
{
|
2014-10-07 23:33:09 +04:00
|
|
|
return color_parse_mem(value, strlen(value), dst);
|
2009-01-20 07:30:30 +03:00
|
|
|
}
|
|
|
|
|
parse_color: refactor color storage
When we parse a color name like "red" into its ANSI color
value, we pack the storage into a single int that may take
on many values:
1. If it's "-2", no value has been specified.
2. If it's "-1", the value is "normal" (i.e., no color).
3. If it's 0 through 7, the value is a standard ANSI
color.
4. If it's larger (up to 255), it is a 256-color extended
value.
Given these magic numbers, it is often hard to see what is
going on in the code. Let's refactor this into a struct with
a flag that tells which scheme we are using, along with a
numeric value. This is more verbose, but should hopefully be
simpler to follow. It will also allow us to easily add
support for more schemes, like 24-bit RGB values.
The result is also slightly less efficient to store, but
that's OK; we only store this intermediate state during the
parse, after which we write out the actual ANSI bytes.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 18:17:05 +03:00
|
|
|
#define COLOR_FOREGROUND '3'
|
|
|
|
#define COLOR_BACKGROUND '4'
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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, const struct color *c, char type)
|
|
|
|
{
|
|
|
|
switch (c->type) {
|
|
|
|
case COLOR_UNSPECIFIED:
|
|
|
|
case COLOR_NORMAL:
|
|
|
|
break;
|
|
|
|
case COLOR_ANSI:
|
|
|
|
*out++ = type;
|
|
|
|
*out++ = '0' + c->value;
|
|
|
|
break;
|
|
|
|
case COLOR_256:
|
|
|
|
out += sprintf(out, "%c8;5;%d", type, c->value);
|
|
|
|
break;
|
2014-11-20 18:25:39 +03:00
|
|
|
case COLOR_RGB:
|
|
|
|
out += sprintf(out, "%c8;2;%d;%d;%d", type,
|
|
|
|
c->red, c->green, c->blue);
|
|
|
|
break;
|
parse_color: refactor color storage
When we parse a color name like "red" into its ANSI color
value, we pack the storage into a single int that may take
on many values:
1. If it's "-2", no value has been specified.
2. If it's "-1", the value is "normal" (i.e., no color).
3. If it's 0 through 7, the value is a standard ANSI
color.
4. If it's larger (up to 255), it is a 256-color extended
value.
Given these magic numbers, it is often hard to see what is
going on in the code. Let's refactor this into a struct with
a flag that tells which scheme we are using, along with a
numeric value. This is more verbose, but should hopefully be
simpler to follow. It will also allow us to easily add
support for more schemes, like 24-bit RGB values.
The result is also slightly less efficient to store, but
that's OK; we only store this intermediate state during the
parse, after which we write out the actual ANSI bytes.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 18:17:05 +03:00
|
|
|
}
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int color_empty(const struct color *c)
|
|
|
|
{
|
|
|
|
return c->type <= COLOR_NORMAL;
|
|
|
|
}
|
|
|
|
|
2014-10-07 23:33:09 +04:00
|
|
|
int color_parse_mem(const char *value, int value_len, char *dst)
|
2006-09-08 12:03:18 +04:00
|
|
|
{
|
|
|
|
const char *ptr = value;
|
2009-01-20 07:30:30 +03:00
|
|
|
int len = value_len;
|
2010-02-28 05:56:38 +03:00
|
|
|
unsigned int attr = 0;
|
parse_color: refactor color storage
When we parse a color name like "red" into its ANSI color
value, we pack the storage into a single int that may take
on many values:
1. If it's "-2", no value has been specified.
2. If it's "-1", the value is "normal" (i.e., no color).
3. If it's 0 through 7, the value is a standard ANSI
color.
4. If it's larger (up to 255), it is a 256-color extended
value.
Given these magic numbers, it is often hard to see what is
going on in the code. Let's refactor this into a struct with
a flag that tells which scheme we are using, along with a
numeric value. This is more verbose, but should hopefully be
simpler to follow. It will also allow us to easily add
support for more schemes, like 24-bit RGB values.
The result is also slightly less efficient to store, but
that's OK; we only store this intermediate state during the
parse, after which we write out the actual ANSI bytes.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 18:17:05 +03:00
|
|
|
struct color fg = { COLOR_UNSPECIFIED };
|
|
|
|
struct color bg = { COLOR_UNSPECIFIED };
|
2006-09-08 12:03:18 +04:00
|
|
|
|
2009-01-20 07:30:30 +03:00
|
|
|
if (!strncasecmp(value, "reset", len)) {
|
2009-02-14 00:53:40 +03:00
|
|
|
strcpy(dst, GIT_COLOR_RESET);
|
2014-10-07 23:33:09 +04:00
|
|
|
return 0;
|
2006-09-08 12:03:18 +04:00
|
|
|
}
|
|
|
|
|
2010-02-28 05:56:38 +03:00
|
|
|
/* [fg [bg]] [attr]... */
|
2009-01-20 07:30:30 +03:00
|
|
|
while (len > 0) {
|
2006-09-08 12:03:18 +04:00
|
|
|
const char *word = ptr;
|
parse_color: refactor color storage
When we parse a color name like "red" into its ANSI color
value, we pack the storage into a single int that may take
on many values:
1. If it's "-2", no value has been specified.
2. If it's "-1", the value is "normal" (i.e., no color).
3. If it's 0 through 7, the value is a standard ANSI
color.
4. If it's larger (up to 255), it is a 256-color extended
value.
Given these magic numbers, it is often hard to see what is
going on in the code. Let's refactor this into a struct with
a flag that tells which scheme we are using, along with a
numeric value. This is more verbose, but should hopefully be
simpler to follow. It will also allow us to easily add
support for more schemes, like 24-bit RGB values.
The result is also slightly less efficient to store, but
that's OK; we only store this intermediate state during the
parse, after which we write out the actual ANSI bytes.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 18:17:05 +03:00
|
|
|
struct color c;
|
2009-01-20 07:30:30 +03:00
|
|
|
int val, wordlen = 0;
|
2006-09-08 12:03:18 +04:00
|
|
|
|
2009-01-20 07:30:30 +03:00
|
|
|
while (len > 0 && !isspace(word[wordlen])) {
|
|
|
|
wordlen++;
|
|
|
|
len--;
|
|
|
|
}
|
2006-09-08 12:03:18 +04:00
|
|
|
|
2009-01-20 07:30:30 +03:00
|
|
|
ptr = word + wordlen;
|
|
|
|
while (len > 0 && isspace(*ptr)) {
|
2006-09-08 12:03:18 +04:00
|
|
|
ptr++;
|
2009-01-20 07:30:30 +03:00
|
|
|
len--;
|
|
|
|
}
|
2006-09-08 12:03:18 +04:00
|
|
|
|
parse_color: refactor color storage
When we parse a color name like "red" into its ANSI color
value, we pack the storage into a single int that may take
on many values:
1. If it's "-2", no value has been specified.
2. If it's "-1", the value is "normal" (i.e., no color).
3. If it's 0 through 7, the value is a standard ANSI
color.
4. If it's larger (up to 255), it is a 256-color extended
value.
Given these magic numbers, it is often hard to see what is
going on in the code. Let's refactor this into a struct with
a flag that tells which scheme we are using, along with a
numeric value. This is more verbose, but should hopefully be
simpler to follow. It will also allow us to easily add
support for more schemes, like 24-bit RGB values.
The result is also slightly less efficient to store, but
that's OK; we only store this intermediate state during the
parse, after which we write out the actual ANSI bytes.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 18:17:05 +03:00
|
|
|
if (!parse_color(&c, word, wordlen)) {
|
|
|
|
if (fg.type == COLOR_UNSPECIFIED) {
|
|
|
|
fg = c;
|
2006-09-08 12:03:18 +04:00
|
|
|
continue;
|
|
|
|
}
|
parse_color: refactor color storage
When we parse a color name like "red" into its ANSI color
value, we pack the storage into a single int that may take
on many values:
1. If it's "-2", no value has been specified.
2. If it's "-1", the value is "normal" (i.e., no color).
3. If it's 0 through 7, the value is a standard ANSI
color.
4. If it's larger (up to 255), it is a 256-color extended
value.
Given these magic numbers, it is often hard to see what is
going on in the code. Let's refactor this into a struct with
a flag that tells which scheme we are using, along with a
numeric value. This is more verbose, but should hopefully be
simpler to follow. It will also allow us to easily add
support for more schemes, like 24-bit RGB values.
The result is also slightly less efficient to store, but
that's OK; we only store this intermediate state during the
parse, after which we write out the actual ANSI bytes.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 18:17:05 +03:00
|
|
|
if (bg.type == COLOR_UNSPECIFIED) {
|
|
|
|
bg = c;
|
2006-09-08 12:03:18 +04:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
goto bad;
|
|
|
|
}
|
2009-01-20 07:30:30 +03:00
|
|
|
val = parse_attr(word, wordlen);
|
2010-02-28 05:56:38 +03:00
|
|
|
if (0 <= val)
|
|
|
|
attr |= (1 << val);
|
|
|
|
else
|
2006-09-08 12:03:18 +04:00
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
|
parse_color: refactor color storage
When we parse a color name like "red" into its ANSI color
value, we pack the storage into a single int that may take
on many values:
1. If it's "-2", no value has been specified.
2. If it's "-1", the value is "normal" (i.e., no color).
3. If it's 0 through 7, the value is a standard ANSI
color.
4. If it's larger (up to 255), it is a 256-color extended
value.
Given these magic numbers, it is often hard to see what is
going on in the code. Let's refactor this into a struct with
a flag that tells which scheme we are using, along with a
numeric value. This is more verbose, but should hopefully be
simpler to follow. It will also allow us to easily add
support for more schemes, like 24-bit RGB values.
The result is also slightly less efficient to store, but
that's OK; we only store this intermediate state during the
parse, after which we write out the actual ANSI bytes.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 18:17:05 +03:00
|
|
|
if (attr || !color_empty(&fg) || !color_empty(&bg)) {
|
2006-09-08 12:03:18 +04:00
|
|
|
int sep = 0;
|
2010-02-28 05:56:38 +03:00
|
|
|
int i;
|
2006-09-08 12:03:18 +04:00
|
|
|
|
|
|
|
*dst++ = '\033';
|
|
|
|
*dst++ = '[';
|
2010-02-28 05:56:38 +03:00
|
|
|
|
|
|
|
for (i = 0; attr; i++) {
|
|
|
|
unsigned bit = (1 << i);
|
|
|
|
if (!(attr & bit))
|
|
|
|
continue;
|
|
|
|
attr &= ~bit;
|
|
|
|
if (sep++)
|
|
|
|
*dst++ = ';';
|
|
|
|
*dst++ = '0' + i;
|
2006-09-08 12:03:18 +04:00
|
|
|
}
|
parse_color: refactor color storage
When we parse a color name like "red" into its ANSI color
value, we pack the storage into a single int that may take
on many values:
1. If it's "-2", no value has been specified.
2. If it's "-1", the value is "normal" (i.e., no color).
3. If it's 0 through 7, the value is a standard ANSI
color.
4. If it's larger (up to 255), it is a 256-color extended
value.
Given these magic numbers, it is often hard to see what is
going on in the code. Let's refactor this into a struct with
a flag that tells which scheme we are using, along with a
numeric value. This is more verbose, but should hopefully be
simpler to follow. It will also allow us to easily add
support for more schemes, like 24-bit RGB values.
The result is also slightly less efficient to store, but
that's OK; we only store this intermediate state during the
parse, after which we write out the actual ANSI bytes.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 18:17:05 +03:00
|
|
|
if (!color_empty(&fg)) {
|
2006-09-08 12:03:18 +04:00
|
|
|
if (sep++)
|
|
|
|
*dst++ = ';';
|
parse_color: refactor color storage
When we parse a color name like "red" into its ANSI color
value, we pack the storage into a single int that may take
on many values:
1. If it's "-2", no value has been specified.
2. If it's "-1", the value is "normal" (i.e., no color).
3. If it's 0 through 7, the value is a standard ANSI
color.
4. If it's larger (up to 255), it is a 256-color extended
value.
Given these magic numbers, it is often hard to see what is
going on in the code. Let's refactor this into a struct with
a flag that tells which scheme we are using, along with a
numeric value. This is more verbose, but should hopefully be
simpler to follow. It will also allow us to easily add
support for more schemes, like 24-bit RGB values.
The result is also slightly less efficient to store, but
that's OK; we only store this intermediate state during the
parse, after which we write out the actual ANSI bytes.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 18:17:05 +03:00
|
|
|
dst = color_output(dst, &fg, COLOR_FOREGROUND);
|
2006-09-08 12:03:18 +04:00
|
|
|
}
|
parse_color: refactor color storage
When we parse a color name like "red" into its ANSI color
value, we pack the storage into a single int that may take
on many values:
1. If it's "-2", no value has been specified.
2. If it's "-1", the value is "normal" (i.e., no color).
3. If it's 0 through 7, the value is a standard ANSI
color.
4. If it's larger (up to 255), it is a 256-color extended
value.
Given these magic numbers, it is often hard to see what is
going on in the code. Let's refactor this into a struct with
a flag that tells which scheme we are using, along with a
numeric value. This is more verbose, but should hopefully be
simpler to follow. It will also allow us to easily add
support for more schemes, like 24-bit RGB values.
The result is also slightly less efficient to store, but
that's OK; we only store this intermediate state during the
parse, after which we write out the actual ANSI bytes.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 18:17:05 +03:00
|
|
|
if (!color_empty(&bg)) {
|
2006-09-08 12:03:18 +04:00
|
|
|
if (sep++)
|
|
|
|
*dst++ = ';';
|
parse_color: refactor color storage
When we parse a color name like "red" into its ANSI color
value, we pack the storage into a single int that may take
on many values:
1. If it's "-2", no value has been specified.
2. If it's "-1", the value is "normal" (i.e., no color).
3. If it's 0 through 7, the value is a standard ANSI
color.
4. If it's larger (up to 255), it is a 256-color extended
value.
Given these magic numbers, it is often hard to see what is
going on in the code. Let's refactor this into a struct with
a flag that tells which scheme we are using, along with a
numeric value. This is more verbose, but should hopefully be
simpler to follow. It will also allow us to easily add
support for more schemes, like 24-bit RGB values.
The result is also slightly less efficient to store, but
that's OK; we only store this intermediate state during the
parse, after which we write out the actual ANSI bytes.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 18:17:05 +03:00
|
|
|
dst = color_output(dst, &bg, COLOR_BACKGROUND);
|
2006-09-08 12:03:18 +04:00
|
|
|
}
|
|
|
|
*dst++ = 'm';
|
|
|
|
}
|
|
|
|
*dst = 0;
|
2014-10-07 23:33:09 +04:00
|
|
|
return 0;
|
2006-09-08 12:03:18 +04:00
|
|
|
bad:
|
2014-10-07 23:33:09 +04:00
|
|
|
return error(_("invalid color value: %.*s"), value_len, value);
|
2006-09-08 12:03:18 +04:00
|
|
|
}
|
|
|
|
|
2011-08-18 09:03:48 +04:00
|
|
|
int git_config_colorbool(const char *var, const char *value)
|
2006-09-08 12:03:18 +04:00
|
|
|
{
|
2007-11-27 01:30:28 +03:00
|
|
|
if (value) {
|
|
|
|
if (!strcasecmp(value, "never"))
|
|
|
|
return 0;
|
|
|
|
if (!strcasecmp(value, "always"))
|
|
|
|
return 1;
|
|
|
|
if (!strcasecmp(value, "auto"))
|
color: delay auto-color decision until point of use
When we read a color value either from a config file or from
the command line, we use git_config_colorbool to convert it
from the tristate always/never/auto into a single yes/no
boolean value.
This has some timing implications with respect to starting
a pager.
If we start (or decide not to start) the pager before
checking the colorbool, everything is fine. Either isatty(1)
will give us the right information, or we will properly
check for pager_in_use().
However, if we decide to start a pager after we have checked
the colorbool, things are not so simple. If stdout is a tty,
then we will have already decided to use color. However, the
user may also have configured color.pager not to use color
with the pager. In this case, we need to actually turn off
color. Unfortunately, the pager code has no idea which color
variables were turned on (and there are many of them
throughout the code, and they may even have been manipulated
after the colorbool selection by something like "--color" on
the command line).
This bug can be seen any time a pager is started after
config and command line options are checked. This has
affected "git diff" since 89d07f7 (diff: don't run pager if
user asked for a diff style exit code, 2007-08-12). It has
also affect the log family since 1fda91b (Fix 'git log'
early pager startup error case, 2010-08-24).
This patch splits the notion of parsing a colorbool and
actually checking the configuration. The "use_color"
variables now have an additional possible value,
GIT_COLOR_AUTO. Users of the variable should use the new
"want_color()" wrapper, which will lazily determine and
cache the auto-color decision.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-18 09:04:23 +04:00
|
|
|
return GIT_COLOR_AUTO;
|
2006-09-08 12:03:18 +04:00
|
|
|
}
|
2007-11-27 01:30:28 +03:00
|
|
|
|
Add an optional argument for --color options
Make git-branch, git-show-branch, git-grep, and all the diff-based
programs accept an optional argument <when> for --color. The argument
is a colorbool: "always", "never", or "auto". If no argument is given,
"always" is used; --no-color is an alias for --color=never. This makes
the command-line interface consistent with other GNU tools, such as `ls'
and `grep', and with the git-config color options. Note that, without
an argument, --color and --no-color work exactly as before.
To implement this, two internal changes were made:
1. Allow the first argument of git_config_colorbool() to be NULL,
in which case it returns -1 if the argument isn't "always", "never",
or "auto".
2. Add OPT_COLOR_FLAG(), OPT__COLOR(), and parse_opt_color_flag_cb()
to the option parsing library. The callback uses
git_config_colorbool(), so color.h is now a dependency
of parse-options.c.
Signed-off-by: Mark Lodato <lodatom@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-02-17 07:55:58 +03:00
|
|
|
if (!var)
|
|
|
|
return -1;
|
|
|
|
|
2007-11-27 01:30:28 +03:00
|
|
|
/* Missing or explicit false to turn off colorization */
|
|
|
|
if (!git_config_bool(var, value))
|
2006-09-08 12:03:18 +04:00
|
|
|
return 0;
|
2007-11-27 01:30:28 +03:00
|
|
|
|
|
|
|
/* any normal truth value defaults to 'auto' */
|
color: delay auto-color decision until point of use
When we read a color value either from a config file or from
the command line, we use git_config_colorbool to convert it
from the tristate always/never/auto into a single yes/no
boolean value.
This has some timing implications with respect to starting
a pager.
If we start (or decide not to start) the pager before
checking the colorbool, everything is fine. Either isatty(1)
will give us the right information, or we will properly
check for pager_in_use().
However, if we decide to start a pager after we have checked
the colorbool, things are not so simple. If stdout is a tty,
then we will have already decided to use color. However, the
user may also have configured color.pager not to use color
with the pager. In this case, we need to actually turn off
color. Unfortunately, the pager code has no idea which color
variables were turned on (and there are many of them
throughout the code, and they may even have been manipulated
after the colorbool selection by something like "--color" on
the command line).
This bug can be seen any time a pager is started after
config and command line options are checked. This has
affected "git diff" since 89d07f7 (diff: don't run pager if
user asked for a diff style exit code, 2007-08-12). It has
also affect the log family since 1fda91b (Fix 'git log'
early pager startup error case, 2010-08-24).
This patch splits the notion of parsing a colorbool and
actually checking the configuration. The "use_color"
variables now have an additional possible value,
GIT_COLOR_AUTO. Users of the variable should use the new
"want_color()" wrapper, which will lazily determine and
cache the auto-color decision.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-18 09:04:23 +04:00
|
|
|
return GIT_COLOR_AUTO;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int check_auto_color(void)
|
|
|
|
{
|
2011-08-18 09:03:48 +04:00
|
|
|
if (color_stdout_is_tty < 0)
|
|
|
|
color_stdout_is_tty = isatty(1);
|
|
|
|
if (color_stdout_is_tty || (pager_in_use() && pager_use_color)) {
|
2007-11-27 01:30:28 +03:00
|
|
|
char *term = getenv("TERM");
|
|
|
|
if (term && strcmp(term, "dumb"))
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
2006-09-08 12:03:18 +04:00
|
|
|
}
|
|
|
|
|
color: delay auto-color decision until point of use
When we read a color value either from a config file or from
the command line, we use git_config_colorbool to convert it
from the tristate always/never/auto into a single yes/no
boolean value.
This has some timing implications with respect to starting
a pager.
If we start (or decide not to start) the pager before
checking the colorbool, everything is fine. Either isatty(1)
will give us the right information, or we will properly
check for pager_in_use().
However, if we decide to start a pager after we have checked
the colorbool, things are not so simple. If stdout is a tty,
then we will have already decided to use color. However, the
user may also have configured color.pager not to use color
with the pager. In this case, we need to actually turn off
color. Unfortunately, the pager code has no idea which color
variables were turned on (and there are many of them
throughout the code, and they may even have been manipulated
after the colorbool selection by something like "--color" on
the command line).
This bug can be seen any time a pager is started after
config and command line options are checked. This has
affected "git diff" since 89d07f7 (diff: don't run pager if
user asked for a diff style exit code, 2007-08-12). It has
also affect the log family since 1fda91b (Fix 'git log'
early pager startup error case, 2010-08-24).
This patch splits the notion of parsing a colorbool and
actually checking the configuration. The "use_color"
variables now have an additional possible value,
GIT_COLOR_AUTO. Users of the variable should use the new
"want_color()" wrapper, which will lazily determine and
cache the auto-color decision.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-18 09:04:23 +04:00
|
|
|
int want_color(int var)
|
|
|
|
{
|
|
|
|
static int want_auto = -1;
|
|
|
|
|
2011-08-18 09:05:35 +04:00
|
|
|
if (var < 0)
|
|
|
|
var = git_use_color_default;
|
|
|
|
|
color: delay auto-color decision until point of use
When we read a color value either from a config file or from
the command line, we use git_config_colorbool to convert it
from the tristate always/never/auto into a single yes/no
boolean value.
This has some timing implications with respect to starting
a pager.
If we start (or decide not to start) the pager before
checking the colorbool, everything is fine. Either isatty(1)
will give us the right information, or we will properly
check for pager_in_use().
However, if we decide to start a pager after we have checked
the colorbool, things are not so simple. If stdout is a tty,
then we will have already decided to use color. However, the
user may also have configured color.pager not to use color
with the pager. In this case, we need to actually turn off
color. Unfortunately, the pager code has no idea which color
variables were turned on (and there are many of them
throughout the code, and they may even have been manipulated
after the colorbool selection by something like "--color" on
the command line).
This bug can be seen any time a pager is started after
config and command line options are checked. This has
affected "git diff" since 89d07f7 (diff: don't run pager if
user asked for a diff style exit code, 2007-08-12). It has
also affect the log family since 1fda91b (Fix 'git log'
early pager startup error case, 2010-08-24).
This patch splits the notion of parsing a colorbool and
actually checking the configuration. The "use_color"
variables now have an additional possible value,
GIT_COLOR_AUTO. Users of the variable should use the new
"want_color()" wrapper, which will lazily determine and
cache the auto-color decision.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-18 09:04:23 +04:00
|
|
|
if (var == GIT_COLOR_AUTO) {
|
|
|
|
if (want_auto < 0)
|
|
|
|
want_auto = check_auto_color();
|
|
|
|
return want_auto;
|
|
|
|
}
|
2011-08-18 09:05:35 +04:00
|
|
|
return var;
|
color: delay auto-color decision until point of use
When we read a color value either from a config file or from
the command line, we use git_config_colorbool to convert it
from the tristate always/never/auto into a single yes/no
boolean value.
This has some timing implications with respect to starting
a pager.
If we start (or decide not to start) the pager before
checking the colorbool, everything is fine. Either isatty(1)
will give us the right information, or we will properly
check for pager_in_use().
However, if we decide to start a pager after we have checked
the colorbool, things are not so simple. If stdout is a tty,
then we will have already decided to use color. However, the
user may also have configured color.pager not to use color
with the pager. In this case, we need to actually turn off
color. Unfortunately, the pager code has no idea which color
variables were turned on (and there are many of them
throughout the code, and they may even have been manipulated
after the colorbool selection by something like "--color" on
the command line).
This bug can be seen any time a pager is started after
config and command line options are checked. This has
affected "git diff" since 89d07f7 (diff: don't run pager if
user asked for a diff style exit code, 2007-08-12). It has
also affect the log family since 1fda91b (Fix 'git log'
early pager startup error case, 2010-08-24).
This patch splits the notion of parsing a colorbool and
actually checking the configuration. The "use_color"
variables now have an additional possible value,
GIT_COLOR_AUTO. Users of the variable should use the new
"want_color()" wrapper, which will lazily determine and
cache the auto-color decision.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-18 09:04:23 +04:00
|
|
|
}
|
|
|
|
|
2011-08-18 09:05:08 +04:00
|
|
|
int git_color_config(const char *var, const char *value, void *cb)
|
2008-02-18 10:26:03 +03:00
|
|
|
{
|
|
|
|
if (!strcmp(var, "color.ui")) {
|
2011-08-18 09:03:48 +04:00
|
|
|
git_use_color_default = git_config_colorbool(var, value);
|
2008-02-18 10:26:03 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-08-18 09:05:08 +04:00
|
|
|
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;
|
|
|
|
|
2008-05-14 21:46:53 +04:00
|
|
|
return git_default_config(var, value, cb);
|
2008-02-18 10:26:03 +03:00
|
|
|
}
|
|
|
|
|
2011-02-26 08:09:41 +03:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2007-09-18 04:06:42 +04:00
|
|
|
static int color_vfprintf(FILE *fp, const char *color, const char *fmt,
|
2006-09-08 12:03:18 +04:00
|
|
|
va_list args, const char *trail)
|
|
|
|
{
|
|
|
|
int r = 0;
|
|
|
|
|
|
|
|
if (*color)
|
2007-09-18 04:06:42 +04:00
|
|
|
r += fprintf(fp, "%s", color);
|
|
|
|
r += vfprintf(fp, fmt, args);
|
2006-09-08 12:03:18 +04:00
|
|
|
if (*color)
|
2009-02-14 00:53:40 +03:00
|
|
|
r += fprintf(fp, "%s", GIT_COLOR_RESET);
|
2006-09-08 12:03:18 +04:00
|
|
|
if (trail)
|
2007-09-18 04:06:42 +04:00
|
|
|
r += fprintf(fp, "%s", trail);
|
2006-09-08 12:03:18 +04:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2007-09-18 04:06:42 +04:00
|
|
|
int color_fprintf(FILE *fp, const char *color, const char *fmt, ...)
|
2006-09-08 12:03:18 +04:00
|
|
|
{
|
|
|
|
va_list args;
|
|
|
|
int r;
|
|
|
|
va_start(args, fmt);
|
2007-09-18 04:06:42 +04:00
|
|
|
r = color_vfprintf(fp, color, fmt, args, NULL);
|
2006-09-08 12:03:18 +04:00
|
|
|
va_end(args);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2007-09-18 04:06:42 +04:00
|
|
|
int color_fprintf_ln(FILE *fp, const char *color, const char *fmt, ...)
|
2006-09-08 12:03:18 +04:00
|
|
|
{
|
|
|
|
va_list args;
|
|
|
|
int r;
|
|
|
|
va_start(args, fmt);
|
2007-09-18 04:06:42 +04:00
|
|
|
r = color_vfprintf(fp, color, fmt, args, "\n");
|
2006-09-08 12:03:18 +04:00
|
|
|
va_end(args);
|
|
|
|
return r;
|
|
|
|
}
|
2010-12-09 20:27:08 +03:00
|
|
|
|
|
|
|
int color_is_nil(const char *c)
|
|
|
|
{
|
|
|
|
return !strcmp(c, "NIL");
|
|
|
|
}
|