node_expando.c

Go to the documentation of this file.

 
#include "config.h"
#include <assert.h>
#include <ctype.h>
#include <limits.h>
#include <stdio.h>
#include "mutt/lib.h"
#include "node_expando.h"
#include "color/lib.h"
#include "definition.h"
#include "format.h"
#include "helpers.h"
#include "mutt_thread.h"
#include "node.h"
#include "parse.h"
#include "render.h"
 
struct NodeExpandoPrivate *node_expando_private_new(void)
{
  struct NodeExpandoPrivate *priv = mutt_mem_calloc(1, sizeof(struct NodeExpandoPrivate));
 
  // NOTE(g0mb4): Expando definition should contain this
  priv->color = -1;
 
  return priv;
}
 
void node_expando_private_free(void **ptr)
{
  if (!ptr || !*ptr)
    return;
 
  FREE(ptr);
}
 
struct ExpandoNode *node_expando_new(const char *start, const char *end,
                                     struct ExpandoFormat *fmt, int did, int uid)
{
  struct ExpandoNode *node = node_new();
 
  node->type = ENT_EXPANDO;
  node->start = start;
  node->end = end;
 
  node->did = did;
  node->uid = uid;
  node->render = node_expando_render;
 
  node->format = fmt;
 
  node->ndata = node_expando_private_new();
  node->ndata_free = node_expando_private_free;
 
  return node;
}
 
void node_expando_set_color(const struct ExpandoNode *node, int cid)
{
  if (!node || (node->type != ENT_EXPANDO) || !node->ndata)
    return;
 
  struct NodeExpandoPrivate *priv = node->ndata;
 
  priv->color = cid;
}
 
void node_expando_set_has_tree(const struct ExpandoNode *node, bool has_tree)
{
  if (!node || (node->type != ENT_EXPANDO) || !node->ndata)
    return;
 
  struct NodeExpandoPrivate *priv = node->ndata;
 
  priv->has_tree = has_tree;
}
 
struct ExpandoFormat *parse_format(const char *start, const char *end,
                                   struct ExpandoParseError *error)
{
  if (start == end)
    return NULL;
 
  struct ExpandoFormat *fmt = mutt_mem_calloc(1, sizeof(struct ExpandoFormat));
 
  fmt->leader = ' ';
  fmt->start = start;
  fmt->end = end;
  fmt->justification = JUSTIFY_RIGHT;
  fmt->min_cols = 0;
  fmt->max_cols = INT_MAX;
 
  if (*start == '-')
  {
    fmt->justification = JUSTIFY_LEFT;
    start++;
  }
  else if (*start == '=')
  {
    fmt->justification = JUSTIFY_CENTER;
    start++;
  }
 
  if (*start == '0')
  {
    fmt->leader = '0';
    start++;
  }
 
  if (isdigit(*start))
  {
    unsigned short number = 0;
    const char *end_ptr = mutt_str_atous(start, &number);
 
    // NOTE(g0mb4): start is NOT null-terminated
    if (!end_ptr || (end_ptr > end) || (number == USHRT_MAX))
    {
      error->position = start;
      snprintf(error->message, sizeof(error->message), _("Invalid number: %s"), start);
      FREE(&fmt);
      return NULL;
    }
 
    fmt->min_cols = number;
    start = end_ptr;
  };
 
  if (*start == '.')
  {
    start++;
 
    if (!isdigit(*start))
    {
      error->position = start;
      // L10N: Expando format expected a number
      snprintf(error->message, sizeof(error->message), _("Number is expected"));
      FREE(&fmt);
      return NULL;
    }
 
    unsigned short number = 0;
    const char *end_ptr = mutt_str_atous(start, &number);
 
    // NOTE(g0mb4): start is NOT null-terminated
    if (!end_ptr || (end_ptr > end) || (number == USHRT_MAX))
    {
      error->position = start;
      snprintf(error->message, sizeof(error->message), _("Invalid number: %s"), start);
      FREE(&fmt);
      return NULL;
    }
 
    fmt->max_cols = number;
    start = end_ptr;
  }
 
  if (*start == '_')
  {
    fmt->lower = true;
    start++;
  }
 
  return fmt;
}
 
struct ExpandoNode *node_expando_parse(const char *str, const char **parsed_until,
                                       const struct ExpandoDefinition *defs,
                                       ExpandoParserFlags flags,
                                       struct ExpandoParseError *error)
{
  const struct ExpandoDefinition *definition = defs;
 
  const char *format_end = skip_until_classic_expando(str);
  const char *expando_end = skip_classic_expando(format_end, defs);
  char expando[128] = { 0 };
  const int expando_len = expando_end - format_end;
  mutt_strn_copy(expando, format_end, expando_len, sizeof(expando));
 
  struct ExpandoFormat *fmt = parse_format(str, format_end, error);
  if (error->position)
  {
    FREE(&fmt);
    return NULL;
  }
 
  while (definition && definition->short_name)
  {
    if (mutt_str_equal(definition->short_name, expando))
    {
      if (definition->parse && !(flags & EP_NO_CUSTOM_PARSE))
      {
        FREE(&fmt);
        return definition->parse(str, parsed_until, definition->did,
                                 definition->uid, flags, error);
      }
      else
      {
        *parsed_until = expando_end;
        return node_expando_new(format_end, expando_end, fmt, definition->did,
                                definition->uid);
      }
    }
 
    definition++;
  }
 
  error->position = format_end;
  // L10N: e.g. "Unknown expando: %Q"
  snprintf(error->message, sizeof(error->message), _("Unknown expando: %%%.*s"),
           expando_len, format_end);
  FREE(&fmt);
  return NULL;
}
 
struct ExpandoNode *node_expando_parse_enclosure(const char *str, const char **parsed_until,
                                                 int did, int uid, char terminator,
                                                 struct ExpandoParseError *error)
{
  const char *format_end = skip_until_classic_expando(str);
 
  format_end++; // skip opening char
 
  const char *expando_end = skip_until_ch(format_end, terminator);
 
  if (*expando_end != terminator)
  {
    error->position = expando_end;
    snprintf(error->message, sizeof(error->message),
             // L10N: Expando is missing a terminator character
             //       e.g. "%[..." is missing the final ']'
             _("Expando is missing terminator: '%c'"), terminator);
    return NULL;
  }
 
  // revert skipping for fmt
  struct ExpandoFormat *fmt = parse_format(str, format_end - 1, error);
  if (error->position)
  {
    FREE(&fmt);
    return NULL;
  }
 
  *parsed_until = expando_end + 1;
  return node_expando_new(format_end, expando_end, fmt, did, uid);
}
 
void add_color(struct Buffer *buf, enum ColorId cid)
{
  assert(cid < MT_COLOR_MAX);
 
  buf_addch(buf, MUTT_SPECIAL_INDEX);
  buf_addch(buf, cid);
}
 
int node_expando_render(const struct ExpandoNode *node,
                        const struct ExpandoRenderData *rdata, struct Buffer *buf,
                        int max_cols, void *data, MuttFormatFlags flags)
{
  assert(node->type == ENT_EXPANDO);
 
  struct Buffer *buf_expando = buf_pool_get();
 
  const struct ExpandoRenderData *rd_match = find_get_string(rdata, node->did, node->uid);
  if (rd_match)
  {
    rd_match->get_string(node, data, flags, max_cols, buf_expando);
  }
  else
  {
    rd_match = find_get_number(rdata, node->did, node->uid);
    assert(rd_match && "Unknown UID");
 
    const long num = rd_match->get_number(node, data, flags);
    buf_printf(buf_expando, "%ld", num);
  }
 
  int total_cols = 0;
 
  const struct NodeExpandoPrivate *priv = node->ndata;
 
  if (priv->color > -1)
    add_color(buf, priv->color);
 
  struct Buffer *tmp = buf_pool_get();
  const struct ExpandoFormat *fmt = node->format;
  if (fmt)
  {
    max_cols = MIN(max_cols, fmt->max_cols);
    int min_cols = MIN(max_cols, fmt->min_cols);
    total_cols += format_string(tmp, min_cols, max_cols, fmt->justification,
                                fmt->leader, buf_string(buf_expando),
                                buf_len(buf_expando), priv->has_tree);
    if (fmt->lower)
      buf_lower_special(tmp);
  }
  else
  {
    total_cols += format_string(tmp, 0, max_cols, JUSTIFY_LEFT, 0, buf_string(buf_expando),
                                buf_len(buf_expando), priv->has_tree);
  }
  buf_addstr(buf, buf_string(tmp));
  buf_pool_release(&tmp);
 
  if (priv->color > -1)
    add_color(buf, MT_COLOR_INDEX);
 
  buf_pool_release(&buf_expando);
  return total_cols;
}