command.c

Go to the documentation of this file.

 
#include "config.h"
#include <stddef.h>
#include <assert.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "parse/lib.h"
#include "color.h"
#include "command2.h"
#include "debug.h"
#include "globals.h"
#include "notify2.h"
#include "quoted.h"
#include "regex4.h"
#include "simple2.h"
#ifdef USE_DEBUG_COLOR
#include <stdio.h>
#include "mutt.h"
#include "pager/lib.h"
#include "attr.h"
#include "curses2.h"
#include "merged.h"
#include "pager/private_data.h" // IWYU pragma: keep
#endif
 
const struct Mapping ColorFields[] = {
  // clang-format off
  { "attachment",        MT_COLOR_ATTACHMENT },
  { "attach_headers",    MT_COLOR_ATTACH_HEADERS },
  { "body",              MT_COLOR_BODY },
  { "bold",              MT_COLOR_BOLD },
  { "error",             MT_COLOR_ERROR },
  { "hdrdefault",        MT_COLOR_HDRDEFAULT },
  { "header",            MT_COLOR_HEADER },
  { "index",             MT_COLOR_INDEX },
  { "index_author",      MT_COLOR_INDEX_AUTHOR },
  { "index_collapsed",   MT_COLOR_INDEX_COLLAPSED },
  { "index_date",        MT_COLOR_INDEX_DATE },
  { "index_flags",       MT_COLOR_INDEX_FLAGS },
  { "index_label",       MT_COLOR_INDEX_LABEL },
  { "index_number",      MT_COLOR_INDEX_NUMBER },
  { "index_size",        MT_COLOR_INDEX_SIZE },
  { "index_subject",     MT_COLOR_INDEX_SUBJECT },
  { "index_tag",         MT_COLOR_INDEX_TAG },
  { "index_tags",        MT_COLOR_INDEX_TAGS },
  { "indicator",         MT_COLOR_INDICATOR },
  { "italic",            MT_COLOR_ITALIC },
  { "markers",           MT_COLOR_MARKERS },
  { "message",           MT_COLOR_MESSAGE },
  { "normal",            MT_COLOR_NORMAL },
  { "options",           MT_COLOR_OPTIONS },
  { "progress",          MT_COLOR_PROGRESS },
  { "prompt",            MT_COLOR_PROMPT },
  { "quoted",            MT_COLOR_QUOTED },
  { "search",            MT_COLOR_SEARCH },
#ifdef USE_SIDEBAR
  { "sidebar_background", MT_COLOR_SIDEBAR_BACKGROUND },
  { "sidebar_divider",   MT_COLOR_SIDEBAR_DIVIDER },
  { "sidebar_flagged",   MT_COLOR_SIDEBAR_FLAGGED },
  { "sidebar_highlight", MT_COLOR_SIDEBAR_HIGHLIGHT },
  { "sidebar_indicator", MT_COLOR_SIDEBAR_INDICATOR },
  { "sidebar_new",       MT_COLOR_SIDEBAR_NEW },
  { "sidebar_ordinary",  MT_COLOR_SIDEBAR_ORDINARY },
  { "sidebar_spool_file", MT_COLOR_SIDEBAR_SPOOLFILE },
  { "sidebar_spoolfile", MT_COLOR_SIDEBAR_SPOOLFILE }, // This will be deprecated
  { "sidebar_unread",    MT_COLOR_SIDEBAR_UNREAD },
#endif
  { "signature",         MT_COLOR_SIGNATURE },
  { "status",            MT_COLOR_STATUS },
  { "stripe_even",       MT_COLOR_STRIPE_EVEN},
  { "stripe_odd",        MT_COLOR_STRIPE_ODD},
  { "tilde",             MT_COLOR_TILDE },
  { "tree",              MT_COLOR_TREE },
  { "underline",         MT_COLOR_UNDERLINE },
  { "warning",           MT_COLOR_WARNING },
  { NULL, 0 },
  // clang-format on
};
 
const struct Mapping ComposeColorFields[] = {
  // clang-format off
  { "header",            MT_COLOR_COMPOSE_HEADER },
  { "security_encrypt",  MT_COLOR_COMPOSE_SECURITY_ENCRYPT },
  { "security_sign",     MT_COLOR_COMPOSE_SECURITY_SIGN },
  { "security_both",     MT_COLOR_COMPOSE_SECURITY_BOTH },
  { "security_none",     MT_COLOR_COMPOSE_SECURITY_NONE },
  { NULL, 0 }
  // clang-format on
};
 
enum ColorPrefix
{
  COLOR_PREFIX_NONE,   
  COLOR_PREFIX_ALERT,  
  COLOR_PREFIX_BRIGHT, 
  COLOR_PREFIX_LIGHT,  
};
 
#ifdef NEOMUTT_DIRECT_COLORS
static uint32_t color_xterm256_to_24bit(const uint32_t color)
{
  static const uint32_t basic[] = {
    0x000000, 0x800000, 0x008000, 0x808000, 0x000080, 0x800080,
    0x008080, 0xc0c0c0, 0x808080, 0xff0000, 0x00ff00, 0xffff00,
    0x0000ff, 0xff00ff, 0x00ffff, 0xffffff,
  };
 
  assert(color < 256);
 
  if (color < 16)
  {
    color_debug(LL_DEBUG5, "Converted color 0-15: %d\n", color);
    /* The first 16 colours are the "usual" terminal colours */
    return basic[color];
  }
 
  if (color < 232)
  {
    /* The Color palette is divided in 6x6x6 colours, i.e. each R, G, B channel
     * has six values:
     *
     *  value: 1     2     3     4     5     6
     *  color: 0x00  0x5f  0x87  0xaf  0xd7  0xff
     *
     * The steps between the values is 0x28 = 40, the EXCEPT for the first one
     * where it is 0x5f = 95.
     *
     * If we express the xterm color number minus 16 to base 6, i.e.
     *
     *    color - 16 = (vr * 36) + (vg * 6) + (vb * 1)
     *
     * with vr, vg, vb integers between 0 and 5, then vr, vg, vb is the channel
     * value for red, green, and blue, respectively.
     */
 
    uint32_t normalised_color = color - 16;
    uint32_t vr = (normalised_color % 216) / 36; /* 216 = 6*6*6 */
    uint32_t vg = (normalised_color % 36) / 6;
    uint32_t vb = (normalised_color % 6) / 1;
 
    /* First step is wider than the other ones, so add the difference if needed */
    uint32_t r = vr * 0x28 + ((vr > 0) ? (0x5f - 0x40) : 0);
    uint32_t g = vg * 0x28 + ((vg > 0) ? (0x5f - 0x40) : 0);
    uint32_t b = vb * 0x28 + ((vb > 0) ? (0x5f - 0x40) : 0);
 
    uint32_t rgb = (r << 16) + (g << 8) + (b << 0);
    color_debug(LL_DEBUG5, "Converted xterm color %d to RGB #%x:\n", color, rgb);
    return rgb;
  }
 
  /* Grey scale starts at 0x08 and adds 0xa = 10 in very step ending in 0xee.
   * There are a total of 6*4 = 24 grey colors in total. */
  uint32_t steps = color - 232;
  uint32_t grey = (steps * 0x0a) + 0x08;
  uint32_t rgb = (grey << 16) + (grey << 8) + (grey << 0);
  color_debug(LL_DEBUG5, "Converted xterm color %d to RGB #%x:\n", color, rgb);
  return rgb;
}
#endif
 
static void modify_color_by_prefix(enum ColorPrefix prefix, bool is_fg,
                                   uint32_t *col, int *attrs)
{
  if (prefix == COLOR_PREFIX_NONE)
    return; // nothing to do here
 
  if (prefix == COLOR_PREFIX_ALERT)
  {
    *attrs |= A_BOLD;
    *attrs |= A_BLINK;
  }
  else if (is_fg)
  {
    if ((COLORS >= 16) && (prefix == COLOR_PREFIX_LIGHT))
    {
      if (*col <= 7)
      {
        /* Advance the color 0-7 by 8 to get the light version */
        *col += 8;
      }
    }
    else
    {
      *attrs |= A_BOLD;
    }
  }
  else
  {
    if (COLORS >= 16)
    {
      if (*col <= 7)
      {
        /* Advance the color 0-7 by 8 to get the light version */
        *col += 8;
      }
    }
  }
}
 
static int parse_color_prefix(const char *s, enum ColorPrefix *prefix)
{
  int clen = 0;
 
  if ((clen = mutt_istr_startswith(s, "bright")))
  {
    color_debug(LL_DEBUG5, "bright\n");
    if (prefix)
      *prefix = COLOR_PREFIX_BRIGHT;
  }
  else if ((clen = mutt_istr_startswith(s, "alert")))
  {
    color_debug(LL_DEBUG5, "alert\n");
    if (prefix)
      *prefix = COLOR_PREFIX_ALERT;
  }
  else if ((clen = mutt_istr_startswith(s, "light")))
  {
    color_debug(LL_DEBUG5, "light\n");
    if (prefix)
      *prefix = COLOR_PREFIX_LIGHT;
  }
 
  return clen;
}
 
static enum CommandResult parse_color_namedcolor(const char *s, uint32_t *col, int *attrs,
                                                 bool is_fg, struct Buffer *err)
{
  enum ColorPrefix prefix = COLOR_PREFIX_NONE;
  s += parse_color_prefix(s, &prefix);
 
  if ((*col = mutt_map_get_value(s, ColorNames)) == -1)
    return MUTT_CMD_WARNING;
 
  const char *name = mutt_map_get_name(*col, ColorNames);
  if (name)
    color_debug(LL_DEBUG5, "color: %s\n", name);
 
  modify_color_by_prefix(prefix, is_fg, col, attrs);
 
#ifdef NEOMUTT_DIRECT_COLORS
  /* If we are running in direct color mode, we must convert the color
   * number 0-15 to an RGB value.
   * The first 16 colours of the xterm palette correspond to the terminal
   * colours. Note that this replace the colour with a predefined RGB value
   * and not the RGB value the terminal configured to use.
   *
   * Note that some colors are "special" e.g. "default" and do not fall in
   * the range from 0 to 15.  These must not be converted.
   */
  const bool c_color_directcolor = cs_subset_bool(NeoMutt->sub, "color_directcolor");
  if (c_color_directcolor && (*col < 16))
  {
    *col = color_xterm256_to_24bit(*col);
  }
#endif
  return MUTT_CMD_SUCCESS;
}
 
static enum CommandResult parse_color_colornnn(const char *s, uint32_t *col, int *attrs,
                                               bool is_fg, struct Buffer *err)
{
  /* prefixes bright, alert, light are only allowed for named colours and
   * colorNNN for backwards compatibility. */
  enum ColorPrefix prefix = COLOR_PREFIX_NONE;
  s += parse_color_prefix(s, &prefix);
 
  int clen = 0;
  /* allow aliases for xterm color resources */
  if ((clen = mutt_istr_startswith(s, "color")) == 0)
    return MUTT_CMD_WARNING;
 
  s += clen;
  char *eptr = NULL;
  *col = strtoul(s, &eptr, 10);
  /* There are only 256 xterm colors.  Do not confuse with COLORS which is
   * the number of colours the terminal supports (usually one of 16, 256,
   * 16777216 (=24bit)). */
  if ((*s == '\0') || (*eptr != '\0') || (*col >= 256) || ((*col >= COLORS) && !OptNoCurses))
  {
    buf_printf(err, _("%s: color not supported by term"), s);
    return MUTT_CMD_ERROR;
  }
 
  modify_color_by_prefix(prefix, is_fg, col, attrs);
 
#ifdef NEOMUTT_DIRECT_COLORS
  const bool c_color_directcolor = cs_subset_bool(NeoMutt->sub, "color_directcolor");
  if (c_color_directcolor)
  {
    /* If we are running in direct color mode, we must convert the xterm
     * color numbers 0-255 to an RGB value. */
    *col = color_xterm256_to_24bit(*col);
    /* FIXME: The color values 0 to 7 (both inclusive) are still occupied by
     * the default terminal colours.  As a workaround we round them up to
     * #000008 which is the blackest black we can produce. */
    if (*col < 8)
      *col = 8;
  }
#endif
  color_debug(LL_DEBUG5, "colorNNN %d\n", *col);
  return MUTT_CMD_SUCCESS;
}
 
static enum CommandResult parse_color_rrggbb(const char *s, uint32_t *col, int *attrs,
                                             bool is_fg, struct Buffer *err)
{
  /* parse #RRGGBB colours */
  if (s[0] != '#')
    return MUTT_CMD_WARNING;
 
#ifndef NEOMUTT_DIRECT_COLORS
  buf_printf(err, _("Direct colors support not compiled in: %s"), s);
  return MUTT_CMD_ERROR;
#endif
  const bool c_color_directcolor = cs_subset_bool(NeoMutt->sub, "color_directcolor");
  if (!c_color_directcolor)
  {
    buf_printf(err, _("Direct colors support disabled: %s"), s);
    return MUTT_CMD_ERROR;
  }
  s++;
  char *eptr = NULL;
  *col = strtoul(s, &eptr, 16);
  if ((*s == '\0') || (*eptr != '\0') || ((*col >= COLORS) && !OptNoCurses))
  {
    buf_printf(err, _("%s: color not supported by term"), s);
    return MUTT_CMD_ERROR;
  }
  /* FIXME: The color values 0 to 7 (both inclusive) are still occupied by
   * the default terminal colours.  As a workaround we round them up to
   * #000008 which is the blackest black we can produce. */
  if (*col < 8)
    *col = 8;
 
  color_debug(LL_DEBUG5, "#RRGGBB: %d\n", *col);
  return MUTT_CMD_SUCCESS;
}
 
static enum CommandResult parse_color_name(const char *s, uint32_t *col, int *attrs,
                                           bool is_fg, struct Buffer *err)
{
  mutt_debug(LL_DEBUG5, "Parsing color name: %s\n", s);
 
  /* Try the different colour syntaxes.  A return value of MUTT_CMD_WARNING
   * means, we should try the next syntax. */
  enum CommandResult cr;
 
  /* #RRGGBB */
  cr = parse_color_rrggbb(s, col, attrs, is_fg, err);
  if (cr != MUTT_CMD_WARNING)
    return cr;
  /* color123 */
  cr = parse_color_colornnn(s, col, attrs, is_fg, err);
  if (cr != MUTT_CMD_WARNING)
    return cr;
  /* named color, e.g. "brightred" */
  cr = parse_color_namedcolor(s, col, attrs, is_fg, err);
  if (cr != MUTT_CMD_WARNING)
    return cr;
 
  buf_printf(err, _("%s: no such color"), s);
  return MUTT_CMD_WARNING;
}
 
static enum CommandResult parse_attr_spec(struct Buffer *buf, struct Buffer *s,
                                          uint32_t *fg, uint32_t *bg,
                                          int *attrs, struct Buffer *err)
{
  if (fg)
    *fg = COLOR_UNSET;
  if (bg)
    *bg = COLOR_UNSET;
 
  if (!MoreArgs(s))
  {
    buf_printf(err, _("%s: too few arguments"), "mono");
    return MUTT_CMD_WARNING;
  }
 
  parse_extract_token(buf, s, TOKEN_NO_FLAGS);
 
  if (mutt_istr_equal("bold", buf->data))
  {
    *attrs |= A_BOLD;
  }
  else if (mutt_istr_equal("italic", buf->data))
  {
    *attrs |= A_ITALIC;
  }
  else if (mutt_istr_equal("none", buf->data))
  {
    *attrs = A_NORMAL; // Use '=' to clear other bits
  }
  else if (mutt_istr_equal("normal", buf->data))
  {
    *attrs = A_NORMAL; // Use '=' to clear other bits
  }
  else if (mutt_istr_equal("reverse", buf->data))
  {
    *attrs |= A_REVERSE;
  }
  else if (mutt_istr_equal("standout", buf->data))
  {
    *attrs |= A_STANDOUT;
  }
  else if (mutt_istr_equal("underline", buf->data))
  {
    *attrs |= A_UNDERLINE;
  }
  else
  {
    buf_printf(err, _("%s: no such attribute"), buf->data);
    return MUTT_CMD_WARNING;
  }
 
  return MUTT_CMD_SUCCESS;
}
 
static enum CommandResult parse_color_pair(struct Buffer *buf, struct Buffer *s,
                                           uint32_t *fg, uint32_t *bg,
                                           int *attrs, struct Buffer *err)
{
  while (true)
  {
    if (!MoreArgsF(s, TOKEN_COMMENT))
    {
      buf_printf(err, _("%s: too few arguments"), "color");
      return MUTT_CMD_WARNING;
    }
 
    parse_extract_token(buf, s, TOKEN_COMMENT);
 
    if (mutt_istr_equal("bold", buf->data))
    {
      *attrs |= A_BOLD;
      color_debug(LL_DEBUG5, "bold\n");
    }
    else if (mutt_istr_equal("italic", buf->data))
    {
      *attrs |= A_ITALIC;
      color_debug(LL_DEBUG5, "italic\n");
    }
    else if (mutt_istr_equal("none", buf->data))
    {
      *attrs = A_NORMAL; // Use '=' to clear other bits
      color_debug(LL_DEBUG5, "none\n");
    }
    else if (mutt_istr_equal("normal", buf->data))
    {
      *attrs = A_NORMAL; // Use '=' to clear other bits
      color_debug(LL_DEBUG5, "normal\n");
    }
    else if (mutt_istr_equal("reverse", buf->data))
    {
      *attrs |= A_REVERSE;
      color_debug(LL_DEBUG5, "reverse\n");
    }
    else if (mutt_istr_equal("standout", buf->data))
    {
      *attrs |= A_STANDOUT;
      color_debug(LL_DEBUG5, "standout\n");
    }
    else if (mutt_istr_equal("underline", buf->data))
    {
      *attrs |= A_UNDERLINE;
      color_debug(LL_DEBUG5, "underline\n");
    }
    else
    {
      enum CommandResult rc = parse_color_name(buf->data, fg, attrs, true, err);
      if (rc != MUTT_CMD_SUCCESS)
        return rc;
      break;
    }
  }
 
  if (!MoreArgsF(s, TOKEN_COMMENT))
  {
    buf_printf(err, _("%s: too few arguments"), "color");
    return MUTT_CMD_WARNING;
  }
 
  parse_extract_token(buf, s, TOKEN_COMMENT);
 
  return parse_color_name(buf->data, bg, attrs, false, err);
}
 
void get_colorid_name(unsigned int cid, struct Buffer *buf)
{
  const char *name = NULL;
 
  if ((cid >= MT_COLOR_COMPOSE_HEADER) && (cid <= MT_COLOR_COMPOSE_SECURITY_SIGN))
  {
    name = mutt_map_get_name(cid, ComposeColorFields);
    if (name)
    {
      buf_printf(buf, "compose %s", name);
      return;
    }
  }
 
  name = mutt_map_get_name(cid, ColorFields);
  if (name)
    buf_addstr(buf, name);
  else
    buf_printf(buf, "UNKNOWN %d", cid);
}
 
static enum CommandResult parse_object(struct Buffer *buf, struct Buffer *s,
                                       enum ColorId *cid, int *ql, struct Buffer *err)
{
  int rc;
 
  if (mutt_str_startswith(buf->data, "quoted") != 0)
  {
    int val = 0;
    if (buf->data[6] != '\0')
    {
      if (!mutt_str_atoi_full(buf->data + 6, &val) || (val > COLOR_QUOTES_MAX))
      {
        buf_printf(err, _("%s: no such object"), buf->data);
        return MUTT_CMD_WARNING;
      }
    }
 
    *ql = val;
    *cid = MT_COLOR_QUOTED;
    return MUTT_CMD_SUCCESS;
  }
 
  if (mutt_istr_equal(buf->data, "compose"))
  {
    if (!MoreArgs(s))
    {
      buf_printf(err, _("%s: too few arguments"), "color");
      return MUTT_CMD_WARNING;
    }
 
    parse_extract_token(buf, s, TOKEN_NO_FLAGS);
 
    rc = mutt_map_get_value(buf->data, ComposeColorFields);
    if (rc == -1)
    {
      buf_printf(err, _("%s: no such object"), buf->data);
      return MUTT_CMD_WARNING;
    }
 
    *cid = rc;
    return MUTT_CMD_SUCCESS;
  }
 
  rc = mutt_map_get_value(buf->data, ColorFields);
  if (rc == -1)
  {
    buf_printf(err, _("%s: no such object"), buf->data);
    return MUTT_CMD_WARNING;
  }
  else
  {
    color_debug(LL_DEBUG5, "object: %s\n", mutt_map_get_name(rc, ColorFields));
  }
 
  *cid = rc;
  return MUTT_CMD_SUCCESS;
}
 
static enum CommandResult parse_uncolor(struct Buffer *buf, struct Buffer *s,
                                        struct Buffer *err, bool uncolor)
{
  parse_extract_token(buf, s, TOKEN_NO_FLAGS);
 
  if (mutt_str_equal(buf->data, "*"))
  {
    colors_cleanup();
    return MUTT_CMD_SUCCESS;
  }
 
  unsigned int cid = MT_COLOR_NONE;
  int ql = 0;
  color_debug(LL_DEBUG5, "uncolor: %s\n", buf_string(buf));
  enum CommandResult rc = parse_object(buf, s, &cid, &ql, err);
  if (rc != MUTT_CMD_SUCCESS)
    return rc;
 
  if (cid == -1)
  {
    buf_printf(err, _("%s: no such object"), buf->data);
    return MUTT_CMD_ERROR;
  }
 
  if (cid == MT_COLOR_QUOTED)
  {
    color_debug(LL_DEBUG5, "quoted\n");
    return quoted_colors_parse_uncolor(cid, ql, err);
  }
 
  if ((cid == MT_COLOR_STATUS) && !MoreArgs(s))
  {
    color_debug(LL_DEBUG5, "simple\n");
    simple_color_reset(cid); // default colour for the status bar
    return MUTT_CMD_SUCCESS;
  }
 
  if (!mutt_color_has_pattern(cid))
  {
    color_debug(LL_DEBUG5, "simple\n");
    simple_color_reset(cid);
    return MUTT_CMD_SUCCESS;
  }
 
  if (OptNoCurses)
  {
    do
    {
      color_debug(LL_DEBUG5, "do nothing\n");
      /* just eat the command, but don't do anything real about it */
      parse_extract_token(buf, s, TOKEN_NO_FLAGS);
    } while (MoreArgs(s));
 
    return MUTT_CMD_SUCCESS;
  }
 
  bool changes = false;
  if (!MoreArgs(s))
  {
    if (regex_colors_parse_uncolor(cid, NULL, uncolor))
      return MUTT_CMD_SUCCESS;
    else
      return MUTT_CMD_ERROR;
  }
 
  do
  {
    parse_extract_token(buf, s, TOKEN_NO_FLAGS);
    if (mutt_str_equal("*", buf->data))
    {
      if (regex_colors_parse_uncolor(cid, NULL, uncolor))
        return MUTT_CMD_SUCCESS;
      else
        return MUTT_CMD_ERROR;
    }
 
    changes |= regex_colors_parse_uncolor(cid, buf->data, uncolor);
 
  } while (MoreArgs(s));
 
  if (changes)
    regex_colors_dump_all();
 
  return MUTT_CMD_SUCCESS;
}
 
#ifdef USE_DEBUG_COLOR
static enum CommandResult color_dump(struct Buffer *buf, struct Buffer *s,
                                     intptr_t data, struct Buffer *err)
{
  if (MoreArgs(s))
    return MUTT_CMD_ERROR;
 
  FILE *fp_out = NULL;
  struct Buffer *tempfile = buf_pool_get();
  struct Buffer filebuf = buf_make(4096);
  char color_fg[32] = { 0 };
  char color_bg[32] = { 0 };
 
  buf_mktemp(tempfile);
  fp_out = mutt_file_fopen(buf_string(tempfile), "w");
  if (!fp_out)
  {
    // L10N: '%s' is the file name of the temporary file
    buf_printf(err, _("Could not create temporary file %s"), buf_string(tempfile));
    buf_dealloc(&filebuf);
    buf_pool_release(&tempfile);
    return MUTT_CMD_ERROR;
  }
 
  buf_addstr(&filebuf, "# All Colours\n\n");
  buf_addstr(&filebuf, "# Simple Colours\n");
  for (enum ColorId cid = MT_COLOR_NONE + 1; cid < MT_COLOR_MAX; cid++)
  {
    struct AttrColor *ac = simple_color_get(cid);
    if (!ac)
      continue;
 
    struct CursesColor *cc = ac->curses_color;
    if (!cc)
      continue;
 
    const char *name = mutt_map_get_name(cid, ColorFields);
    if (!name)
      continue;
 
    const char *swatch = color_debug_log_color_attrs(cc->fg, cc->bg, ac->attrs);
    buf_add_printf(&filebuf, "color %-18s %-30s %-8s %-8s # %s\n", name,
                   color_debug_log_attrs_list(ac->attrs),
                   color_debug_log_name(color_fg, sizeof(color_fg), cc->fg),
                   color_debug_log_name(color_bg, sizeof(color_bg), cc->bg), swatch);
  }
 
  if (NumQuotedColors > 0)
  {
    buf_addstr(&filebuf, "\n# Quoted Colours\n");
    for (int i = 0; i < NumQuotedColors; i++)
    {
      struct AttrColor *ac = quoted_colors_get(i);
      if (!ac)
        continue;
 
      struct CursesColor *cc = ac->curses_color;
      if (!cc)
        continue;
 
      const char *swatch = color_debug_log_color_attrs(cc->fg, cc->bg, ac->attrs);
      buf_add_printf(&filebuf, "color quoted%d %-30s %-8s %-8s # %s\n", i,
                     color_debug_log_attrs_list(ac->attrs),
                     color_debug_log_name(color_fg, sizeof(color_fg), cc->fg),
                     color_debug_log_name(color_bg, sizeof(color_bg), cc->bg), swatch);
    }
  }
 
  int rl_count = 0;
  for (enum ColorId id = MT_COLOR_NONE; id != MT_COLOR_MAX; ++id)
  {
    if (!mutt_color_has_pattern(id))
    {
      continue;
    }
 
    struct RegexColorList *rcl = regex_colors_get_list(id);
    if (!STAILQ_EMPTY(rcl))
      rl_count++;
  }
 
  if (rl_count > 0)
  {
    for (enum ColorId id = MT_COLOR_NONE; id != MT_COLOR_MAX; ++id)
    {
      if (!mutt_color_has_pattern(id))
      {
        continue;
      }
 
      struct RegexColorList *rcl = regex_colors_get_list(id);
      if (STAILQ_EMPTY(rcl))
        continue;
 
      const char *name = mutt_map_get_name(id, ColorFields);
      if (!name)
        continue;
 
      buf_add_printf(&filebuf, "\n# Regex Colour %s\n", name);
 
      struct RegexColor *rc = NULL;
      STAILQ_FOREACH(rc, rcl, entries)
      {
        struct AttrColor *ac = &rc->attr_color;
        struct CursesColor *cc = ac->curses_color;
        if (!cc)
          continue;
 
        const char *swatch = color_debug_log_color_attrs(cc->fg, cc->bg, ac->attrs);
        buf_add_printf(&filebuf, "color %-14s %-30s %-8s %-8s %-30s # %s\n",
                       name, color_debug_log_attrs_list(ac->attrs),
                       color_debug_log_name(color_fg, sizeof(color_fg), cc->fg),
                       color_debug_log_name(color_bg, sizeof(color_bg), cc->bg),
                       rc->pattern, swatch);
      }
    }
  }
 
#ifdef USE_DEBUG_COLOR
  if (!TAILQ_EMPTY(&MergedColors))
  {
    buf_addstr(&filebuf, "\n# Merged Colours\n");
    struct AttrColor *ac = NULL;
    TAILQ_FOREACH(ac, &MergedColors, entries)
    {
      struct CursesColor *cc = ac->curses_color;
      if (!cc)
        continue;
 
      const char *swatch = color_debug_log_color_attrs(cc->fg, cc->bg, ac->attrs);
      buf_add_printf(&filebuf, "# %-30s %-8s %-8s # %s\n",
                     color_debug_log_attrs_list(ac->attrs),
                     color_debug_log_name(color_fg, sizeof(color_fg), cc->fg),
                     color_debug_log_name(color_bg, sizeof(color_bg), cc->bg), swatch);
    }
  }
 
  struct MuttWindow *win = window_get_focus();
  if (win && (win->type == WT_CUSTOM) && win->parent && (win->parent->type == WT_PAGER))
  {
    struct PagerPrivateData *priv = win->parent->wdata;
    if (priv && !TAILQ_EMPTY(&priv->ansi_list))
    {
      buf_addstr(&filebuf, "\n# Ansi Colours\n");
      struct AttrColor *ac = NULL;
      TAILQ_FOREACH(ac, &priv->ansi_list, entries)
      {
        struct CursesColor *cc = ac->curses_color;
        if (!cc)
          continue;
 
        const char *swatch = color_debug_log_color_attrs(cc->fg, cc->bg, ac->attrs);
        buf_add_printf(&filebuf, "# %-30s %-8s %-8s # %s\n",
                       color_debug_log_attrs_list(ac->attrs),
                       color_debug_log_name(color_fg, sizeof(color_fg), cc->fg),
                       color_debug_log_name(color_bg, sizeof(color_bg), cc->bg), swatch);
      }
    }
  }
#endif
 
  fputs(filebuf.data, fp_out);
 
  mutt_file_fclose(&fp_out);
  buf_dealloc(&filebuf);
 
  struct PagerData pdata = { 0 };
  struct PagerView pview = { &pdata };
 
  pdata.fname = buf_string(tempfile);
 
  pview.banner = "color";
  pview.flags = MUTT_SHOWCOLOR;
  pview.mode = PAGER_MODE_OTHER;
 
  mutt_do_pager(&pview, NULL);
  buf_pool_release(&tempfile);
 
  return MUTT_CMD_SUCCESS;
}
#endif
 
static enum CommandResult parse_color(struct Buffer *buf, struct Buffer *s,
                                      struct Buffer *err, parser_callback_t callback,
                                      bool dry_run, bool color)
{
  int attrs = 0, q_level = 0;
  uint32_t fg = 0, bg = 0, match = 0;
  enum ColorId cid = MT_COLOR_NONE;
  enum CommandResult rc;
 
  if (!MoreArgs(s))
  {
#ifdef USE_DEBUG_COLOR
    if (StartupComplete)
      return color_dump(buf, s, 0, err);
#endif
 
    buf_printf(err, _("%s: too few arguments"), "color");
    return MUTT_CMD_WARNING;
  }
 
  parse_extract_token(buf, s, TOKEN_NO_FLAGS);
  color_debug(LL_DEBUG5, "color: %s\n", buf_string(buf));
 
  rc = parse_object(buf, s, &cid, &q_level, err);
  if (rc != MUTT_CMD_SUCCESS)
    return rc;
 
  rc = callback(buf, s, &fg, &bg, &attrs, err);
  if (rc != MUTT_CMD_SUCCESS)
    return rc;
 
  /* extract a regular expression if needed */
 
  if (mutt_color_has_pattern(cid) && cid != MT_COLOR_STATUS)
  {
    color_debug(LL_DEBUG5, "regex needed\n");
    if (MoreArgs(s))
    {
      parse_extract_token(buf, s, TOKEN_NO_FLAGS);
    }
    else
    {
      buf_strcpy(buf, ".*");
    }
  }
 
  if (MoreArgs(s) && (cid != MT_COLOR_STATUS))
  {
    buf_printf(err, _("%s: too many arguments"), color ? "color" : "mono");
    return MUTT_CMD_WARNING;
  }
 
  if (dry_run)
  {
    color_debug(LL_DEBUG5, "dry_run bailout\n");
    *s->dptr = '\0'; /* fake that we're done parsing */
    return MUTT_CMD_SUCCESS;
  }
 
  /* The case of the tree object is special, because a non-default fg color of
   * the tree element may be combined dynamically with the default bg color of
   * an index line, not necessarily defined in a rc file.  */
  if (!OptNoCurses &&
      ((fg == COLOR_DEFAULT) || (bg == COLOR_DEFAULT) || (cid == MT_COLOR_TREE)) &&
      (use_default_colors() != OK))
  {
    buf_strcpy(err, _("default colors not supported"));
    return MUTT_CMD_ERROR;
  }
 
  if (regex_colors_parse_color_list(cid, buf->data, fg, bg, attrs, &rc, err))
  {
    color_debug(LL_DEBUG5, "regex_colors_parse_color_list done\n");
    return rc;
    // do nothing
  }
  else if (quoted_colors_parse_color(cid, fg, bg, attrs, q_level, &rc, err))
  {
    color_debug(LL_DEBUG5, "quoted_colors_parse_color done\n");
    return rc;
    // do nothing
  }
  else if ((cid == MT_COLOR_STATUS) && MoreArgs(s))
  {
    color_debug(LL_DEBUG5, "status\n");
    /* 'color status fg bg' can have up to 2 arguments:
     * 0 arguments: sets the default status color (handled below by else part)
     * 1 argument : colorize pattern on match
     * 2 arguments: colorize nth submatch of pattern */
    parse_extract_token(buf, s, TOKEN_NO_FLAGS);
 
    if (MoreArgs(s))
    {
      struct Buffer tmp = buf_make(0);
      parse_extract_token(&tmp, s, TOKEN_NO_FLAGS);
      if (!mutt_str_atoui_full(tmp.data, &match))
      {
        buf_printf(err, _("%s: invalid number: %s"), color ? "color" : "mono", tmp.data);
        buf_dealloc(&tmp);
        return MUTT_CMD_WARNING;
      }
      buf_dealloc(&tmp);
    }
 
    if (MoreArgs(s))
    {
      buf_printf(err, _("%s: too many arguments"), color ? "color" : "mono");
      return MUTT_CMD_WARNING;
    }
 
    rc = regex_colors_parse_status_list(cid, buf->data, fg, bg, attrs, match, err);
    return rc;
  }
  else // Remaining simple colours
  {
    color_debug(LL_DEBUG5, "simple\n");
    if (simple_color_set(cid, fg, bg, attrs))
      rc = MUTT_CMD_SUCCESS;
    else
      rc = MUTT_CMD_ERROR;
  }
 
  if (rc == MUTT_CMD_SUCCESS)
  {
    get_colorid_name(cid, buf);
    color_debug(LL_DEBUG5, "NT_COLOR_SET: %s\n", buf->data);
    struct EventColor ev_c = { cid, NULL };
    notify_send(ColorsNotify, NT_COLOR, NT_COLOR_SET, &ev_c);
  }
 
  return rc;
}
 
enum CommandResult mutt_parse_uncolor(struct Buffer *buf, struct Buffer *s,
                                      intptr_t data, struct Buffer *err)
{
  if (OptNoCurses)
  {
    *s->dptr = '\0'; /* fake that we're done parsing */
    return MUTT_CMD_SUCCESS;
  }
  color_debug(LL_DEBUG5, "parse: %s\n", buf_string(buf));
  enum CommandResult rc = parse_uncolor(buf, s, err, true);
  curses_colors_dump();
  return rc;
}
 
enum CommandResult mutt_parse_unmono(struct Buffer *buf, struct Buffer *s,
                                     intptr_t data, struct Buffer *err)
{
  *s->dptr = '\0'; /* fake that we're done parsing */
  return MUTT_CMD_SUCCESS;
}
 
enum CommandResult mutt_parse_color(struct Buffer *buf, struct Buffer *s,
                                    intptr_t data, struct Buffer *err)
{
  bool dry_run = OptNoCurses;
 
  color_debug(LL_DEBUG5, "parse: %s\n", buf_string(buf));
  enum CommandResult rc = parse_color(buf, s, err, parse_color_pair, dry_run, true);
  curses_colors_dump();
  return rc;
}
 
enum CommandResult mutt_parse_mono(struct Buffer *buf, struct Buffer *s,
                                   intptr_t data, struct Buffer *err)
{
  return parse_color(buf, s, err, parse_attr_spec, true, false);
}