sort.c

Go to the documentation of this file.

 
#include "config.h"
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include "mutt/lib.h"
#include "sort.h"
#include "set.h"
#include "types.h"

#define PREFIX_REVERSE "reverse-"
#define PREFIX_LAST "last-"

static int sort_string_set(void *var, struct ConfigDef *cdef, const char *value,
                           struct Buffer *err)
{
  intptr_t id = -1;
  uint16_t flags = 0;
 
  if (!value || (value[0] == '\0'))
  {
    buf_printf(err, _("Option %s may not be empty"), cdef->name);
    return CSR_ERR_INVALID | CSR_INV_TYPE;
  }
 
  size_t plen = 0;
 
  if (cdef->type & D_SORT_REVERSE)
  {
    plen = mutt_str_startswith(value, PREFIX_REVERSE);
    if (plen != 0)
    {
      flags |= SORT_REVERSE;
      value += plen;
    }
  }
 
  if (cdef->type & D_SORT_LAST)
  {
    plen = mutt_str_startswith(value, PREFIX_LAST);
    if (plen != 0)
    {
      flags |= SORT_LAST;
      value += plen;
    }
  }
 
  id = mutt_map_get_value(value, (struct Mapping *) cdef->data);
 
  if (id < 0)
  {
    buf_printf(err, _("Invalid value for %s"), cdef->name);
    const struct Mapping *map = (const struct Mapping *) cdef->data;
    if (map)
    {
      buf_addch(err, '\n');
      struct Buffer *list = buf_pool_get();
      int count = 0;
      for (int i = 0; map[i].name; i++)
      {
        // Skip compatibility aliases (duplicate values)
        bool dominated = false;
        for (int j = 0; j < i; j++)
        {
          if (map[j].value == map[i].value)
          {
            dominated = true;
            break;
          }
        }
        if (dominated)
          continue;
 
        if (count > 0)
          buf_addstr(list, ", ");
        buf_addstr(list, map[i].name);
        count++;
      }
      buf_add_printf(err, _("Choose from: %s"), buf_string(list));
      buf_pool_release(&list);
    }
    return CSR_ERR_INVALID | CSR_INV_TYPE | CSR_INV_WARNING;
  }
 
  id |= flags;
 
  if (var)
  {
    if (id == (*(short *) var))
      return CSR_SUCCESS | CSR_SUC_NO_CHANGE;
 
    if (startup_only(cdef, err))
      return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
 
    if (cdef->validator)
    {
      int rc = cdef->validator(cdef, (intptr_t) id, err);
 
      if (CSR_RESULT(rc) != CSR_SUCCESS)
        return rc | CSR_INV_VALIDATOR;
    }
 
    *(short *) var = id;
  }
  else
  {
    cdef->initial = id;
  }
 
  return CSR_SUCCESS;
}

static int sort_string_get(void *var, const struct ConfigDef *cdef, struct Buffer *result)
{
  int sort;
 
  if (var)
    sort = *(short *) var;
  else
    sort = (int) cdef->initial;
 
  if (sort & SORT_REVERSE)
    buf_addstr(result, PREFIX_REVERSE);
  if (sort & SORT_LAST)
    buf_addstr(result, PREFIX_LAST);
 
  sort &= SORT_MASK;
 
  const char *str = NULL;
 
  str = mutt_map_get_name(sort, (struct Mapping *) cdef->data);
 
  if (!str)
  {
    mutt_debug(LL_DEBUG1, "Variable has an invalid value: %d/%d\n", cdef->type, sort);
    return CSR_ERR_INVALID | CSR_INV_TYPE;
  }
 
  buf_addstr(result, str);
  return CSR_SUCCESS;
}

static int sort_native_set(void *var, const struct ConfigDef *cdef,
                           intptr_t value, struct Buffer *err)
{
  const char *str = NULL;
 
  str = mutt_map_get_name((value & SORT_MASK), (struct Mapping *) cdef->data);
 
  if (!str)
  {
    buf_printf(err, _("Invalid sort type: %ld"), (long) value);
    return CSR_ERR_INVALID | CSR_INV_TYPE;
  }
 
  if (value == (*(short *) var))
    return CSR_SUCCESS | CSR_SUC_NO_CHANGE;
 
  if (startup_only(cdef, err))
    return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
 
  if (cdef->validator)
  {
    int rc = cdef->validator(cdef, value, err);
 
    if (CSR_RESULT(rc) != CSR_SUCCESS)
      return rc | CSR_INV_VALIDATOR;
  }
 
  *(short *) var = value;
  return CSR_SUCCESS;
}

static intptr_t sort_native_get(void *var, const struct ConfigDef *cdef, struct Buffer *err)
{
  return *(short *) var;
}

static bool sort_has_been_set(void *var, const struct ConfigDef *cdef)
{
  return (cdef->initial != (*(short *) var));
}

static int sort_reset(void *var, const struct ConfigDef *cdef, struct Buffer *err)
{
  if (cdef->initial == (*(short *) var))
    return CSR_SUCCESS | CSR_SUC_NO_CHANGE;
 
  if (startup_only(cdef, err))
    return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
 
  if (cdef->validator)
  {
    int rc = cdef->validator(cdef, cdef->initial, err);
 
    if (CSR_RESULT(rc) != CSR_SUCCESS)
      return rc | CSR_INV_VALIDATOR;
  }
 
  *(short *) var = cdef->initial;
  return CSR_SUCCESS;
}

const struct ConfigSetType CstSort = {
  DT_SORT,
  "sort",
  sort_string_set,
  sort_string_get,
  sort_native_set,
  sort_native_get,
  NULL, // string_plus_equals
  NULL, // string_minus_equals
  sort_has_been_set,
  sort_reset,
  NULL, // destroy
};