mbtable.c

Go to the documentation of this file.

 
#include "config.h"
#include <stdint.h>
#include <string.h>
#include <wchar.h>
#include "mutt/lib.h"
#include "mbtable.h"
#include "set.h"
#include "types.h"
 
bool mbtable_equal(const struct MbTable *a, const struct MbTable *b)
{
  if (!a && !b) /* both empty */
    return true;
  if (!a ^ !b) /* one is empty, but not the other */
    return false;
 
  return mutt_str_equal(a->orig_str, b->orig_str);
}
 
struct MbTable *mbtable_parse(const char *s)
{
  struct MbTable *t = NULL;
  size_t slen, k;
  mbstate_t mbstate = { 0 };
  char *d = NULL;
 
  slen = mutt_str_len(s);
  if (!slen)
    return NULL;
 
  t = mutt_mem_calloc(1, sizeof(struct MbTable));
 
  t->orig_str = mutt_str_dup(s);
  /* This could be more space efficient.  However, being used on tiny
   * strings (`$to_chars` and `$status_chars`), the overhead is not great. */
  t->chars = mutt_mem_calloc(slen, sizeof(char *));
  t->segmented_str = mutt_mem_calloc(slen * 2, sizeof(char));
  d = t->segmented_str;
 
  while (slen && (k = mbrtowc(NULL, s, slen, &mbstate)))
  {
    if ((k == ICONV_ILLEGAL_SEQ) || (k == ICONV_BUF_TOO_SMALL))
    {
      /* XXX put message in err buffer; fail? warning? */
      mutt_debug(LL_DEBUG1, "mbrtowc returned %zd converting %s in %s\n", k, s, t->orig_str);
      if (k == ICONV_ILLEGAL_SEQ)
        memset(&mbstate, 0, sizeof(mbstate));
      k = (k == ICONV_ILLEGAL_SEQ) ? 1 : slen;
    }
 
    slen -= k;
    t->chars[t->len++] = d;
    while (k--)
      *d++ = *s++;
    *d++ = '\0';
  }
 
  return t;
}
 
static void mbtable_destroy(const struct ConfigSet *cs, void *var, const struct ConfigDef *cdef)
{
  struct MbTable **m = var;
  if (!*m)
    return;
 
  mbtable_free(m);
}
 
static int mbtable_string_set(const struct ConfigSet *cs, void *var, struct ConfigDef *cdef,
                              const char *value, struct Buffer *err)
{
  /* Store empty mbtables as NULL */
  if (value && (value[0] == '\0'))
    value = NULL;
 
  struct MbTable *table = NULL;
 
  int rc = CSR_SUCCESS;
 
  if (var)
  {
    struct MbTable *curval = *(struct MbTable **) var;
    if (curval && mutt_str_equal(value, curval->orig_str))
      return CSR_SUCCESS | CSR_SUC_NO_CHANGE;
 
    if (startup_only(cdef, err))
      return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
 
    table = mbtable_parse(value);
 
    if (cdef->validator)
    {
      rc = cdef->validator(cs, cdef, (intptr_t) table, err);
 
      if (CSR_RESULT(rc) != CSR_SUCCESS)
      {
        mbtable_free(&table);
        return rc | CSR_INV_VALIDATOR;
      }
    }
 
    mbtable_destroy(cs, var, cdef);
 
    *(struct MbTable **) var = table;
 
    if (!table)
      rc |= CSR_SUC_EMPTY;
  }
  else
  {
    if (cdef->type & D_INTERNAL_INITIAL_SET)
      FREE(&cdef->initial);
 
    cdef->type |= D_INTERNAL_INITIAL_SET;
    cdef->initial = (intptr_t) mutt_str_dup(value);
  }
 
  return rc;
}
 
static int mbtable_string_get(const struct ConfigSet *cs, void *var,
                              const struct ConfigDef *cdef, struct Buffer *result)
{
  const char *str = NULL;
 
  if (var)
  {
    struct MbTable *table = *(struct MbTable **) var;
    if (!table || !table->orig_str)
      return CSR_SUCCESS | CSR_SUC_EMPTY; /* empty string */
    str = table->orig_str;
  }
  else
  {
    str = (char *) cdef->initial;
  }
 
  buf_addstr(result, str);
  return CSR_SUCCESS;
}
 
static struct MbTable *mbtable_dup(struct MbTable *table)
{
  if (!table)
    return NULL; /* LCOV_EXCL_LINE */
 
  struct MbTable *m = mutt_mem_calloc(1, sizeof(*m));
  m->orig_str = mutt_str_dup(table->orig_str);
  return m;
}
 
static int mbtable_native_set(const struct ConfigSet *cs, void *var,
                              const struct ConfigDef *cdef, intptr_t value,
                              struct Buffer *err)
{
  int rc;
 
  if (mbtable_equal(*(struct MbTable **) var, (struct MbTable *) value))
    return CSR_SUCCESS | CSR_SUC_NO_CHANGE;
 
  if (startup_only(cdef, err))
    return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
 
  if (cdef->validator)
  {
    rc = cdef->validator(cs, cdef, value, err);
 
    if (CSR_RESULT(rc) != CSR_SUCCESS)
      return rc | CSR_INV_VALIDATOR;
  }
 
  mbtable_free(var);
 
  struct MbTable *table = mbtable_dup((struct MbTable *) value);
 
  rc = CSR_SUCCESS;
  if (!table)
    rc |= CSR_SUC_EMPTY;
 
  *(struct MbTable **) var = table;
  return rc;
}
 
static intptr_t mbtable_native_get(const struct ConfigSet *cs, void *var,
                                   const struct ConfigDef *cdef, struct Buffer *err)
{
  struct MbTable *table = *(struct MbTable **) var;
 
  return (intptr_t) table;
}
 
static int mbtable_reset(const struct ConfigSet *cs, void *var,
                         const struct ConfigDef *cdef, struct Buffer *err)
{
  struct MbTable *table = NULL;
  const char *initial = (const char *) cdef->initial;
 
  struct MbTable *curtable = *(struct MbTable **) var;
  const char *curval = curtable ? curtable->orig_str : NULL;
 
  int rc = CSR_SUCCESS;
  if (!curtable)
    rc |= CSR_SUC_EMPTY;
 
  if (mutt_str_equal(initial, curval))
    return rc | CSR_SUC_NO_CHANGE;
 
  if (startup_only(cdef, err))
    return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
 
  if (initial)
    table = mbtable_parse(initial);
 
  if (cdef->validator)
  {
    rc = cdef->validator(cs, cdef, (intptr_t) table, err);
 
    if (CSR_RESULT(rc) != CSR_SUCCESS)
    {
      mbtable_destroy(cs, &table, cdef);
      return rc | CSR_INV_VALIDATOR;
    }
  }
 
  if (!table)
    rc |= CSR_SUC_EMPTY;
 
  mbtable_destroy(cs, var, cdef);
 
  *(struct MbTable **) var = table;
  return rc;
}
 
void mbtable_free(struct MbTable **ptr)
{
  if (!ptr || !*ptr)
    return;
 
  struct MbTable *table = *ptr;
  FREE(&table->orig_str);
  FREE(&table->chars);
  FREE(&table->segmented_str);
 
  FREE(ptr);
}
 
const char *mbtable_get_nth_wchar(const struct MbTable *table, int index)
{
  if (!table || !table->chars || (index < 0) || (index >= table->len))
    return " ";
 
  if (table->chars[index][0] == '\r')
    return "";
 
  return table->chars[index];
}
 
const struct ConfigSetType CstMbtable = {
  DT_MBTABLE,
  "mbtable",
  mbtable_string_set,
  mbtable_string_get,
  mbtable_native_set,
  mbtable_native_get,
  NULL, // string_plus_equals
  NULL, // string_minus_equals
  mbtable_reset,
  mbtable_destroy,
};