parse_color.c

Go to the documentation of this file.

 
#include "config.h"
#include <stddef.h>
#include <stdbool.h>
#include <stdlib.h>
#include "mutt/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "parse_color.h"
#include "parse/lib.h"
#include "attr.h"
#include "color.h"
#include "debug.h"
 
const struct Mapping ColorNames[] = {
  // clang-format off
  { "black",   COLOR_BLACK },
  { "blue",    COLOR_BLUE },
  { "cyan",    COLOR_CYAN },
  { "green",   COLOR_GREEN },
  { "magenta", COLOR_MAGENTA },
  { "red",     COLOR_RED },
  { "white",   COLOR_WHITE },
  { "yellow",  COLOR_YELLOW },
  { "default", COLOR_DEFAULT },
  { 0, 0 },
  // clang-format on
};
 
static struct Mapping AttributeNames[] = {
  // clang-format off
  { "bold",      A_BOLD      },
  { "italic",    A_ITALIC    },
  { "none",      A_NORMAL    },
  { "normal",    A_NORMAL    },
  { "reverse",   A_REVERSE   },
  { "standout",  A_STANDOUT  },
  { "underline", A_UNDERLINE },
  { NULL, 0 },
  // clang-format on
};
 
int parse_color_prefix(const char *s, enum ColorPrefix *prefix)
{
  if (!s || !prefix)
    return 0;
 
  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;
}
 
enum CommandResult parse_color_namedcolor(const char *s, struct ColorElement *elem,
                                          struct Buffer *err)
{
  if (!s || !elem)
    return MUTT_CMD_ERROR;
 
  // COLOR_DEFAULT (-1) interferes with mutt_map_get_value()
  if (mutt_str_equal(s, "default"))
  {
    elem->color = COLOR_DEFAULT;
    elem->type = CT_SIMPLE;
    elem->prefix = COLOR_PREFIX_NONE;
    return MUTT_CMD_SUCCESS;
  }
 
  enum ColorPrefix prefix = COLOR_PREFIX_NONE;
  s += parse_color_prefix(s, &prefix);
 
  int color = mutt_map_get_value(s, ColorNames);
  if (color == -1)
    return MUTT_CMD_WARNING;
 
  elem->color = color;
  elem->type = CT_SIMPLE;
  elem->prefix = prefix;
 
  const char *name = mutt_map_get_name(elem->color, ColorNames);
  if (name)
    color_debug(LL_DEBUG5, "color: %s\n", name);
 
  return MUTT_CMD_SUCCESS;
}
 
enum CommandResult parse_color_colornnn(const char *s, struct ColorElement *elem,
                                        struct Buffer *err)
{
  if (!s || !elem)
    return MUTT_CMD_ERROR;
 
  /* 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;
 
  unsigned long color = 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') || (color >= 256))
  {
    buf_printf(err, _("%s: color not supported by term"), s);
    return MUTT_CMD_ERROR;
  }
 
  elem->color = color;
  elem->type = CT_PALETTE;
  elem->prefix = prefix;
 
  color_debug(LL_DEBUG5, "colorNNN %d\n", elem->color);
  return MUTT_CMD_SUCCESS;
}
 
enum CommandResult parse_color_rrggbb(const char *s, struct ColorElement *elem,
                                      struct Buffer *err)
{
  if (!s || !elem)
    return MUTT_CMD_ERROR;
 
  /* parse #RRGGBB colours */
  if (s[0] != '#')
    return MUTT_CMD_WARNING;
 
  s++;
  char *eptr = NULL;
  unsigned long color = strtoul(s, &eptr, 16);
 
  if ((*s == '\0') || !eptr || (*eptr != '\0') || ((eptr - s) != 6))
  {
    buf_printf(err, _("%s: color not supported by term"), s);
    return MUTT_CMD_ERROR;
  }
 
  elem->color = color;
  elem->type = CT_RGB;
  elem->prefix = COLOR_PREFIX_NONE;
 
  color_debug(LL_DEBUG5, "#RRGGBB: %ld\n", color);
  return MUTT_CMD_SUCCESS;
}
 
enum CommandResult parse_color_name(const char *s, struct ColorElement *elem,
                                    struct Buffer *err)
{
  color_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, elem, err);
  if (cr != MUTT_CMD_WARNING)
    return cr;
 
  /* color123 */
  cr = parse_color_colornnn(s, elem, err);
  if (cr != MUTT_CMD_WARNING)
    return cr;
 
  /* named color, e.g. "brightred" */
  cr = parse_color_namedcolor(s, elem, err);
  if (cr != MUTT_CMD_WARNING)
    return cr;
 
  buf_printf(err, _("%s: no such color"), s);
  return MUTT_CMD_WARNING;
}
 
enum CommandResult parse_color_pair(struct Buffer *buf, struct Buffer *s,
                                    struct AttrColor *ac, 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 (buf_is_empty(buf))
      continue;
 
    int attr = mutt_map_get_value(buf->data, AttributeNames);
    if (attr == -1)
    {
      enum CommandResult rc = parse_color_name(buf->data, &ac->fg, err);
      if (rc != MUTT_CMD_SUCCESS)
        return rc;
      break;
    }
 
    if (attr == A_NORMAL)
      ac->attrs = attr; // Clear all attributes
    else
      ac->attrs |= attr; // Merge with other attributes
  }
 
  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, &ac->bg, err);
}
 
enum CommandResult parse_attr_spec(struct Buffer *buf, struct Buffer *s,
                                   struct AttrColor *ac, struct Buffer *err)
{
  if (!buf || !s || !ac)
    return MUTT_CMD_ERROR;
 
  if (!MoreArgs(s))
  {
    buf_printf(err, _("%s: too few arguments"), "mono");
    return MUTT_CMD_WARNING;
  }
 
  parse_extract_token(buf, s, TOKEN_NO_FLAGS);
 
  int attr = mutt_map_get_value(buf->data, AttributeNames);
  if (attr == -1)
  {
    buf_printf(err, _("%s: no such attribute"), buf->data);
    return MUTT_CMD_WARNING;
  }
 
  if (attr == A_NORMAL)
    ac->attrs = attr; // Clear all attributes
  else
    ac->attrs |= attr; // Merge with other attributes
 
  return MUTT_CMD_SUCCESS;
}