number.c

Go to the documentation of this file.

 
#include "config.h"
#include <limits.h>
#include <stddef.h>
#include <stdint.h>
#include "mutt/lib.h"
#include "number.h"
#include "set.h"
#include "subset.h"
#include "types.h"
 
#define TOGGLE_BIT ((SHRT_MAX + 1) << 1)
static intptr_t native_get(void *var)
{
  // take care of endianess and always read intptr_t value
  intptr_t v = *(intptr_t *) var;
  return (v & TOGGLE_BIT) ? 0 : (short) v;
}
 
static void native_set(void *var, intptr_t val)
{
  // cast to unsigned short to clear any pending toggle status bits
  val = (unsigned short) val;
  *(intptr_t *) var = val;
}
 
static void native_toggle(void *var)
{
  *(intptr_t *) var = *(uintptr_t *) var ^ TOGGLE_BIT;
}
 
static int number_string_set(const struct ConfigSet *cs, void *var, struct ConfigDef *cdef,
                             const char *value, struct Buffer *err)
{
  int num = 0;
  if (value && *value && !mutt_str_atoi_full(value, &num))
  {
    buf_printf(err, _("Invalid number: %s"), value);
    return CSR_ERR_INVALID | CSR_INV_TYPE;
  }
 
  if ((num < SHRT_MIN) || (num > SHRT_MAX))
  {
    buf_printf(err, _("Number is too big: %s"), value);
    return CSR_ERR_INVALID | CSR_INV_TYPE;
  }
 
  if ((num < 0) && (cdef->type & D_INTEGER_NOT_NEGATIVE))
  {
    buf_printf(err, _("Option %s may not be negative"), cdef->name);
    return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
  }
 
  if (var)
  {
    if (num == native_get(var))
      return CSR_SUCCESS | CSR_SUC_NO_CHANGE;
 
    if (cdef->validator)
    {
      int rc = cdef->validator(cs, cdef, (intptr_t) num, err);
 
      if (CSR_RESULT(rc) != CSR_SUCCESS)
        return rc | CSR_INV_VALIDATOR;
    }
 
    if (startup_only(cdef, err))
      return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
 
    native_set(var, num);
  }
  else
  {
    cdef->initial = num;
  }
 
  return CSR_SUCCESS;
}
 
static int number_string_get(const struct ConfigSet *cs, void *var,
                             const struct ConfigDef *cdef, struct Buffer *result)
{
  int value;
 
  if (var)
    value = native_get(var);
  else
    value = (int) cdef->initial;
 
  buf_printf(result, "%d", value);
  return CSR_SUCCESS;
}
 
static int number_native_set(const struct ConfigSet *cs, void *var,
                             const struct ConfigDef *cdef, intptr_t value,
                             struct Buffer *err)
{
  if ((value < SHRT_MIN) || (value > SHRT_MAX))
  {
    buf_printf(err, _("Invalid number: %ld"), (long) value);
    return CSR_ERR_INVALID | CSR_INV_TYPE;
  }
 
  if ((value < 0) && (cdef->type & D_INTEGER_NOT_NEGATIVE))
  {
    buf_printf(err, _("Option %s may not be negative"), cdef->name);
    return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
  }
 
  if (value == native_get(var))
    return CSR_SUCCESS | CSR_SUC_NO_CHANGE;
 
  if (cdef->validator)
  {
    int rc = cdef->validator(cs, cdef, value, err);
 
    if (CSR_RESULT(rc) != CSR_SUCCESS)
      return rc | CSR_INV_VALIDATOR;
  }
 
  if (startup_only(cdef, err))
    return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
 
  native_set(var, value);
  return CSR_SUCCESS;
}
 
static intptr_t number_native_get(const struct ConfigSet *cs, void *var,
                                  const struct ConfigDef *cdef, struct Buffer *err)
{
  return native_get(var);
}
 
static int number_string_plus_equals(const struct ConfigSet *cs, void *var,
                                     const struct ConfigDef *cdef,
                                     const char *value, struct Buffer *err)
{
  int num = 0;
  if (!mutt_str_atoi_full(value, &num))
  {
    buf_printf(err, _("Invalid number: %s"), NONULL(value));
    return CSR_ERR_INVALID | CSR_INV_TYPE;
  }
 
  int result = number_native_get(NULL, var, NULL, NULL) + num;
  if ((result < SHRT_MIN) || (result > SHRT_MAX))
  {
    buf_printf(err, _("Number is too big: %s"), value);
    return CSR_ERR_INVALID | CSR_INV_TYPE;
  }
 
  if ((result < 0) && (cdef->type & D_INTEGER_NOT_NEGATIVE))
  {
    buf_printf(err, _("Option %s may not be negative"), cdef->name);
    return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
  }
 
  if (cdef->validator)
  {
    int rc = cdef->validator(cs, cdef, (intptr_t) result, err);
 
    if (CSR_RESULT(rc) != CSR_SUCCESS)
      return rc | CSR_INV_VALIDATOR;
  }
 
  if (startup_only(cdef, err))
    return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
 
  native_set(var, result);
  return CSR_SUCCESS;
}
 
static int number_string_minus_equals(const struct ConfigSet *cs, void *var,
                                      const struct ConfigDef *cdef,
                                      const char *value, struct Buffer *err)
{
  int num = 0;
  if (!mutt_str_atoi(value, &num))
  {
    buf_printf(err, _("Invalid number: %s"), NONULL(value));
    return CSR_ERR_INVALID | CSR_INV_TYPE;
  }
 
  int result = native_get(var) - num;
  if ((result < SHRT_MIN) || (result > SHRT_MAX))
  {
    buf_printf(err, _("Number is too big: %s"), value);
    return CSR_ERR_INVALID | CSR_INV_TYPE;
  }
 
  if ((result < 0) && (cdef->type & D_INTEGER_NOT_NEGATIVE))
  {
    buf_printf(err, _("Option %s may not be negative"), cdef->name);
    return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
  }
 
  if (cdef->validator)
  {
    int rc = cdef->validator(cs, cdef, (intptr_t) result, err);
 
    if (CSR_RESULT(rc) != CSR_SUCCESS)
      return rc | CSR_INV_VALIDATOR;
  }
 
  if (startup_only(cdef, err))
    return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
 
  native_set(var, result);
  return CSR_SUCCESS;
}
 
static int number_reset(const struct ConfigSet *cs, void *var,
                        const struct ConfigDef *cdef, struct Buffer *err)
{
  if (cdef->initial == native_get(var))
    return CSR_SUCCESS | CSR_SUC_NO_CHANGE;
 
  if (cdef->validator)
  {
    int rc = cdef->validator(cs, cdef, cdef->initial, err);
 
    if (CSR_RESULT(rc) != CSR_SUCCESS)
      return rc | CSR_INV_VALIDATOR;
  }
 
  if (startup_only(cdef, err))
    return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
 
  native_set(var, cdef->initial);
  return CSR_SUCCESS;
}
 
int number_he_toggle(struct ConfigSubset *sub, struct HashElem *he, struct Buffer *err)
{
  if (!sub || !he || !he->data)
    return CSR_ERR_CODE;
 
  struct HashElem *he_base = cs_get_base(he);
  if (DTYPE(he_base->type) != DT_NUMBER)
    return CSR_ERR_CODE;
 
  struct ConfigDef *cdef = he_base->data;
  native_toggle(&cdef->var);
 
  cs_subset_notify_observers(sub, he, NT_CONFIG_SET);
 
  return CSR_SUCCESS;
}
 
const struct ConfigSetType CstNumber = {
  DT_NUMBER,
  "number",
  number_string_set,
  number_string_get,
  number_native_set,
  number_native_get,
  number_string_plus_equals,
  number_string_minus_equals,
  number_reset,
  NULL, // destroy
};