text: /* Output colorization.
     Copyright (C) 2011-2019 Free Software Foundation, Inc.
  
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 3, or (at your option)
     any later version.
  
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
  
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
     02110-1301, USA.  */
  
  #include "config.h"
  #include "system.h"
  #include "diagnostic-color.h"
  
  #ifdef __MINGW32__
  #  include <windows.h>
  #endif
  
  #include "color-macros.h"
  
  /* The context and logic for choosing default --color screen attributes
     (foreground and background colors, etc.) are the following.
        -- There are eight basic colors available, each with its own
  	 nominal luminosity to the human eye and foreground/background
  	 codes (black [0 %, 30/40], blue [11 %, 34/44], red [30 %, 31/41],
  	 magenta [41 %, 35/45], green [59 %, 32/42], cyan [70 %, 36/46],
  	 yellow [89 %, 33/43], and white [100 %, 37/47]).
        -- Sometimes, white as a background is actually implemented using
  	 a shade of light gray, so that a foreground white can be visible
  	 on top of it (but most often not).
        -- Sometimes, black as a foreground is actually implemented using
  	 a shade of dark gray, so that it can be visible on top of a
  	 background black (but most often not).
        -- Sometimes, more colors are available, as extensions.
        -- Other attributes can be selected/deselected (bold [1/22],
  	 underline [4/24], standout/inverse [7/27], blink [5/25], and
  	 invisible/hidden [8/28]).  They are sometimes implemented by
  	 using colors instead of what their names imply; e.g., bold is
  	 often achieved by using brighter colors.  In practice, only bold
  	 is really available to us, underline sometimes being mapped by
  	 the terminal to some strange color choice, and standout best
  	 being left for use by downstream programs such as less(1).
        -- We cannot assume that any of the extensions or special features
  	 are available for the purpose of choosing defaults for everyone.
        -- The most prevalent default terminal backgrounds are pure black
  	 and pure white, and are not necessarily the same shades of
  	 those as if they were selected explicitly with SGR sequences.
  	 Some terminals use dark or light pictures as default background,
  	 but those are covered over by an explicit selection of background
  	 color with an SGR sequence; their users will appreciate their
  	 background pictures not be covered like this, if possible.
        -- Some uses of colors attributes is to make some output items
  	 more understated (e.g., context lines); this cannot be achieved
  	 by changing the background color.
        -- For these reasons, the GCC color defaults should strive not
  	 to change the background color from its default, unless it's
  	 for a short item that should be highlighted, not understated.
        -- The GCC foreground color defaults (without an explicitly set
  	 background) should provide enough contrast to be readable on any
  	 terminal with either a black (dark) or white (light) background.
  	 This only leaves red, magenta, green, and cyan (and their bold
  	 counterparts) and possibly bold blue.  */
  /* Default colors. The user can overwrite them using environment
     variable GCC_COLORS.  */
  struct color_cap
  {
    const char *name;
    const char *val;
    unsigned char name_len;
    bool free_val;
  };
  
  /* For GCC_COLORS.  */
  static struct color_cap color_dict[] =
  {
    { "error", SGR_SEQ (COLOR_BOLD COLOR_SEPARATOR COLOR_FG_RED), 5, false },
    { "warning", SGR_SEQ (COLOR_BOLD COLOR_SEPARATOR COLOR_FG_MAGENTA),
  	       7, false },
    { "note", SGR_SEQ (COLOR_BOLD COLOR_SEPARATOR COLOR_FG_CYAN), 4, false },
    { "range1", SGR_SEQ (COLOR_FG_GREEN), 6, false },
    { "range2", SGR_SEQ (COLOR_FG_BLUE), 6, false },
    { "locus", SGR_SEQ (COLOR_BOLD), 5, false },
    { "quote", SGR_SEQ (COLOR_BOLD), 5, false },
    { "fixit-insert", SGR_SEQ (COLOR_FG_GREEN), 12, false },
    { "fixit-delete", SGR_SEQ (COLOR_FG_RED), 12, false },
    { "diff-filename", SGR_SEQ (COLOR_BOLD), 13, false },
    { "diff-hunk", SGR_SEQ (COLOR_FG_CYAN), 9, false },
    { "diff-delete", SGR_SEQ (COLOR_FG_RED), 11, false },
    { "diff-insert", SGR_SEQ (COLOR_FG_GREEN), 11, false },
    { "type-diff", SGR_SEQ (COLOR_BOLD COLOR_SEPARATOR COLOR_FG_GREEN), 9, false },
    { NULL, NULL, 0, false }
  };
  
  const char *
  colorize_start (bool show_color, const char *name, size_t name_len)
  {
    struct color_cap const *cap;
  
    if (!show_color)
      return "";
  
    for (cap = color_dict; cap->name; cap++)
      if (cap->name_len == name_len
  	&& memcmp (cap->name, name, name_len) == 0)
        break;
    if (cap->name == NULL)
      return "";
  
    return cap->val;
  }
  
  const char *
  colorize_stop (bool show_color)
  {
    return show_color ? SGR_RESET : "";
  }
  
  /* Parse GCC_COLORS.  The default would look like:
     GCC_COLORS='error=01;31:warning=01;35:note=01;36:\
     range1=32:range2=34:locus=01:quote=01:\
     fixit-insert=32:fixit-delete=31:'\
     diff-filename=01:diff-hunk=32:diff-delete=31:diff-insert=32:\
     type-diff=01;32'
     No character escaping is needed or supported.  */
  static bool
  parse_gcc_colors (void)
  {
    const char *p, *q, *name, *val;
    char *b;
    size_t name_len = 0, val_len = 0;
  
    p = getenv ("GCC_COLORS"); /* Plural! */
    if (p == NULL)
      return true;
    if (*p == '\0')
      return false;
  
    name = q = p;
    val = NULL;
    /* From now on, be well-formed or you're gone.  */
    for (;;)
      if (*q == ':' || *q == '\0')
        {
  	struct color_cap *cap;
  
  	if (val)
  	  val_len = q - val;
  	else
  	  name_len = q - name;
  	/* Empty name without val (empty cap)
  	   won't match and will be ignored.  */
  	for (cap = color_dict; cap->name; cap++)
  	  if (cap->name_len == name_len
  	      && memcmp (cap->name, name, name_len) == 0)
  	    break;
  	/* If name unknown, go on for forward compatibility.  */
  	if (cap->val && val)
  	  {
  	    if (cap->free_val)
  	      free (CONST_CAST (char *, cap->val));
  	    b = XNEWVEC (char, val_len + sizeof (SGR_SEQ ("")));
  	    memcpy (b, SGR_START, strlen (SGR_START));
  	    memcpy (b + strlen (SGR_START), val, val_len);
  	    memcpy (b + strlen (SGR_START) + val_len, SGR_END,
  		    sizeof (SGR_END));
  	    cap->val = (const char *) b;
  	    cap->free_val = true;
  	  }
  	if (*q == '\0')
  	  return true;
  	name = ++q;
  	val = NULL;
        }
      else if (*q == '=')
        {
  	if (q == name || val)
  	  return true;
  
  	name_len = q - name;
  	val = ++q; /* Can be the empty string.  */
        }
      else if (val == NULL)
        q++; /* Accumulate name.  */
      else if (*q == ';' || (*q >= '0' && *q <= '9'))
        q++; /* Accumulate val.  Protect the terminal from being sent
  	      garbage.  */
      else
        return true;
  }
  
  /* Return true if we should use color when in auto mode, false otherwise. */
  static bool
  should_colorize (void)
  {
  #ifdef __MINGW32__
    /* For consistency reasons, one should check the handle returned by
       _get_osfhandle(_fileno(stderr)) because the function
       pp_write_text_to_stream() in pretty-print.c calls fputs() on
       that stream.  However, the code below for non-Windows doesn't seem
       to care about it either...  */
    HANDLE h;
    DWORD m;
  
    h = GetStdHandle (STD_ERROR_HANDLE);
    return (h != INVALID_HANDLE_VALUE) && (h != NULL)
  	  && GetConsoleMode (h, &m);
  #else
    char const *t = getenv ("TERM");
    return t && strcmp (t, "dumb") != 0 && isatty (STDERR_FILENO);
  #endif
  }
  
  bool
  colorize_init (diagnostic_color_rule_t rule)
  {
    switch (rule)
      {
      case DIAGNOSTICS_COLOR_NO:
        return false;
      case DIAGNOSTICS_COLOR_YES:
        return parse_gcc_colors ();
      case DIAGNOSTICS_COLOR_AUTO:
        if (should_colorize ())
  	return parse_gcc_colors ();
        else
  	return false;
      default:
        gcc_unreachable ();
      }
  }
  