bool.c

Go to the documentation of this file.

 
#include "config.h"
#include <limits.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include "mutt/lib.h"
#include "bool.h"
#include "set.h"
#include "subset.h"
#include "types.h"

const char *BoolValues[] = {
  "no", "yes", "n", "y", "false", "true", "0", "1", "off", "on", NULL,
};

static int bool_string_set(void *var, struct ConfigDef *cdef, const char *value,
                           struct Buffer *err)
{
  if (!value)
    return CSR_ERR_CODE; /* LCOV_EXCL_LINE */
 
  int num = -1;
  for (size_t i = 0; BoolValues[i]; i++)
  {
    if (mutt_istr_equal(BoolValues[i], value))
    {
      num = i % 2;
      break;
    }
  }
 
  if (num < 0)
  {
    buf_printf(err, _("Invalid value for %s"), cdef->name);
    buf_addch(err, '\n');
    buf_add_printf(err, _("Choose from: %s"), "no, yes");
    return CSR_ERR_INVALID | CSR_INV_TYPE | CSR_INV_WARNING;
  }
 
  if (var)
  {
    if (num == (*(bool *) 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) num, err);
 
      if (CSR_RESULT(rc) != CSR_SUCCESS)
        return rc | CSR_INV_VALIDATOR;
    }
 
    *(bool *) var = num;
  }
  else
  {
    cdef->initial = num;
  }
 
  return CSR_SUCCESS;
}

static int bool_string_get(void *var, const struct ConfigDef *cdef, struct Buffer *result)
{
  int index;
 
  if (var)
    index = *(bool *) var;
  else
    index = (int) cdef->initial;
 
  if (index > 1)
    return CSR_ERR_INVALID | CSR_INV_TYPE; /* LCOV_EXCL_LINE */
 
  buf_addstr(result, BoolValues[index]);
  return CSR_SUCCESS;
}

static int bool_native_set(void *var, const struct ConfigDef *cdef,
                           intptr_t value, struct Buffer *err)
{
  if ((value < 0) || (value > 1))
  {
    buf_printf(err, _("Invalid boolean value: %ld"), (long) value);
    return CSR_ERR_INVALID | CSR_INV_TYPE;
  }
 
  if (value == (*(bool *) 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;
  }
 
  *(bool *) var = value;
  return CSR_SUCCESS;
}

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

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

static int bool_reset(void *var, const struct ConfigDef *cdef, struct Buffer *err)
{
  if (cdef->initial == (*(bool *) 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;
  }
 
  *(bool *) var = cdef->initial;
  return CSR_SUCCESS;
}

int bool_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 (CONFIG_TYPE(he_base->type) != DT_BOOL)
    return CSR_ERR_CODE;
 
  intptr_t value = cs_he_native_get(sub->cs, he, err);
  if (value == INT_MIN)
    return CSR_ERR_CODE;
 
  int rc = cs_he_native_set(sub->cs, he, !value, err);
 
  if ((CSR_RESULT(rc) == CSR_SUCCESS) && !(rc & CSR_SUC_NO_CHANGE))
    cs_subset_notify_observers(sub, he, NT_CONFIG_SET);
 
  return rc;
}

int bool_str_toggle(struct ConfigSubset *sub, const char *name, struct Buffer *err)
{
  struct HashElem *he = cs_subset_create_inheritance(sub, name);
 
  return bool_he_toggle(sub, he, err);
}

const struct ConfigSetType CstBool = {
  DT_BOOL,
  "boolean",
  bool_string_set,
  bool_string_get,
  bool_native_set,
  bool_native_get,
  NULL, // string_plus_equals
  NULL, // string_minus_equals
  bool_has_been_set,
  bool_reset,
  NULL, // destroy
};