set.c

Go to the documentation of this file.

 
#include "config.h"
#include <stdbool.h>
#include <stdio.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "mutt.h"
#include "set.h"
#include "dump.h"
#include "extract.h"
#include "muttlib.h"
#include "perror.h"

void command_set_expand_value(int type, struct Buffer *value)
{
  ASSERT(value);
  if (CONFIG_TYPE(type) == DT_PATH)
  {
    if (type & (D_PATH_DIR | D_PATH_FILE))
      expand_path(value, false);
    else
      mutt_path_tilde(value, NeoMutt->home_dir);
  }
  else if (IS_MAILBOX(type))
  {
    expand_path(value, false);
  }
  else if (IS_COMMAND(type))
  {
    struct Buffer *scratch = buf_pool_get();
    buf_copy(scratch, value);
 
    if (!mutt_str_equal(value->data, "builtin"))
    {
      expand_path(scratch, false);
    }
    buf_reset(value);
    buf_addstr(value, buf_string(scratch));
    buf_pool_release(&scratch);
  }
}

enum CommandResult command_set_set(struct Buffer *name, struct Buffer *value,
                                   struct Buffer *err)
{
  ASSERT(name);
  ASSERT(value);
  struct HashElem *he = cs_subset_lookup(NeoMutt->sub, name->data);
  if (!he)
  {
    // In case it is a my_var, we have to create it
    if (mutt_str_startswith(name->data, "my_"))
    {
      struct ConfigDef my_cdef = { 0 };
      my_cdef.name = name->data;
      my_cdef.type = DT_MYVAR;
      he = cs_create_variable(NeoMutt->sub->cs, &my_cdef, err);
      if (!he)
        return MUTT_CMD_ERROR; // LCOV_EXCL_LINE
    }
    else
    {
      buf_printf(err, _("Unknown option %s"), name->data);
      return MUTT_CMD_ERROR;
    }
  }
 
  if (he->type & D_INTERNAL_DEPRECATED)
  {
    mutt_warning(_("Option %s is deprecated"), name->data);
    return MUTT_CMD_SUCCESS;
  }
  int rc = CSR_ERR_CODE;
 
  if (CONFIG_TYPE(he->type) == DT_MYVAR)
  {
    // my variables do not expand their value
    rc = cs_subset_he_string_set(NeoMutt->sub, he, value->data, err);
  }
  else
  {
    command_set_expand_value(he->type, value);
    rc = cs_subset_he_string_set(NeoMutt->sub, he, value->data, err);
  }
  if (CSR_RESULT(rc) != CSR_SUCCESS)
    return MUTT_CMD_ERROR; // LCOV_EXCL_LINE
 
  return MUTT_CMD_SUCCESS;
}

enum CommandResult command_set_increment(struct Buffer *name,
                                         struct Buffer *value, struct Buffer *err)
{
  ASSERT(name);
  ASSERT(value);
  struct HashElem *he = cs_subset_lookup(NeoMutt->sub, name->data);
  if (!he)
  {
    // In case it is a my_var, we have to create it
    if (mutt_str_startswith(name->data, "my_"))
    {
      struct ConfigDef my_cdef = { 0 };
      my_cdef.name = name->data;
      my_cdef.type = DT_MYVAR;
      he = cs_create_variable(NeoMutt->sub->cs, &my_cdef, err);
      if (!he)
        return MUTT_CMD_ERROR; // LCOV_EXCL_LINE
    }
    else
    {
      buf_printf(err, _("Unknown option %s"), name->data);
      return MUTT_CMD_ERROR;
    }
  }
 
  if (he->type & D_INTERNAL_DEPRECATED)
  {
    mutt_warning(_("Option %s is deprecated"), name->data);
    return MUTT_CMD_SUCCESS;
  }
 
  int rc = CSR_ERR_CODE;
 
  if (CONFIG_TYPE(he->type) == DT_MYVAR)
  {
    // my variables do not expand their value
    rc = cs_subset_he_string_plus_equals(NeoMutt->sub, he, value->data, err);
  }
  else
  {
    command_set_expand_value(he->type, value);
    rc = cs_subset_he_string_plus_equals(NeoMutt->sub, he, value->data, err);
  }
  if (CSR_RESULT(rc) != CSR_SUCCESS)
    return MUTT_CMD_ERROR;
 
  return MUTT_CMD_SUCCESS;
}

enum CommandResult command_set_decrement(struct Buffer *name,
                                         struct Buffer *value, struct Buffer *err)
{
  ASSERT(name);
  ASSERT(value);
  struct HashElem *he = cs_subset_lookup(NeoMutt->sub, name->data);
  if (!he)
  {
    buf_printf(err, _("Unknown option %s"), name->data);
    return MUTT_CMD_ERROR;
  }
 
  if (he->type & D_INTERNAL_DEPRECATED)
  {
    mutt_warning(_("Option %s is deprecated"), name->data);
    return MUTT_CMD_SUCCESS;
  }
 
  command_set_expand_value(he->type, value);
  int rc = cs_subset_he_string_minus_equals(NeoMutt->sub, he, value->data, err);
  if (CSR_RESULT(rc) != CSR_SUCCESS)
    return MUTT_CMD_ERROR;
 
  return MUTT_CMD_SUCCESS;
}

enum CommandResult command_set_unset(struct Buffer *name, struct Buffer *err)
{
  ASSERT(name);
  struct HashElem *he = cs_subset_lookup(NeoMutt->sub, name->data);
  if (!he)
  {
    buf_printf(err, _("Unknown option %s"), name->data);
    return MUTT_CMD_ERROR;
  }
 
  if (he->type & D_INTERNAL_DEPRECATED)
  {
    mutt_warning(_("Option %s is deprecated"), name->data);
    return MUTT_CMD_SUCCESS;
  }
 
  int rc = CSR_ERR_CODE;
  if (CONFIG_TYPE(he->type) == DT_MYVAR)
  {
    rc = cs_subset_he_delete(NeoMutt->sub, he, err);
  }
  else if ((CONFIG_TYPE(he->type) == DT_BOOL) || (CONFIG_TYPE(he->type) == DT_QUAD))
  {
    rc = cs_subset_he_native_set(NeoMutt->sub, he, false, err);
  }
  else
  {
    rc = cs_subset_he_string_set(NeoMutt->sub, he, NULL, err);
  }
  if (CSR_RESULT(rc) != CSR_SUCCESS)
    return MUTT_CMD_ERROR; // LCOV_EXCL_LINE
 
  return MUTT_CMD_SUCCESS;
}

enum CommandResult command_set_reset(struct Buffer *name, struct Buffer *err)
{
  ASSERT(name);
  // Handle special "reset all" syntax
  if (mutt_str_equal(name->data, "all"))
  {
    struct HashElemArray hea = get_elem_list(NeoMutt->sub->cs, GEL_ALL_CONFIG);
    struct HashElem **hep = NULL;
    ARRAY_FOREACH(hep, &hea)
    {
      struct HashElem *he = *hep;
      if (CONFIG_TYPE(he->type) == DT_MYVAR)
        cs_subset_he_delete(NeoMutt->sub, he, err);
      else
        cs_subset_he_reset(NeoMutt->sub, he, NULL);
    }
 
    ARRAY_FREE(&hea);
    return MUTT_CMD_SUCCESS;
  }
 
  struct HashElem *he = cs_subset_lookup(NeoMutt->sub, name->data);
  if (!he)
  {
    buf_printf(err, _("Unknown option %s"), name->data);
    return MUTT_CMD_ERROR;
  }
 
  if (he->type & D_INTERNAL_DEPRECATED)
  {
    mutt_warning(_("Option %s is deprecated"), name->data);
    return MUTT_CMD_SUCCESS;
  }
 
  int rc = CSR_ERR_CODE;
  if (CONFIG_TYPE(he->type) == DT_MYVAR)
  {
    rc = cs_subset_he_delete(NeoMutt->sub, he, err);
  }
  else
  {
    rc = cs_subset_he_reset(NeoMutt->sub, he, err);
  }
  if (CSR_RESULT(rc) != CSR_SUCCESS)
    return MUTT_CMD_ERROR; // LCOV_EXCL_LINE
 
  return MUTT_CMD_SUCCESS;
}

enum CommandResult command_set_toggle(struct Buffer *name, struct Buffer *err)
{
  ASSERT(name);
  struct HashElem *he = cs_subset_lookup(NeoMutt->sub, name->data);
  if (!he)
  {
    buf_printf(err, _("Unknown option %s"), name->data);
    return MUTT_CMD_ERROR;
  }
 
  if (he->type & D_INTERNAL_DEPRECATED)
  {
    mutt_warning(_("Option %s is deprecated"), name->data);
    return MUTT_CMD_SUCCESS;
  }
 
  if (CONFIG_TYPE(he->type) == DT_BOOL)
  {
    bool_he_toggle(NeoMutt->sub, he, err);
  }
  else if (CONFIG_TYPE(he->type) == DT_QUAD)
  {
    quad_he_toggle(NeoMutt->sub, he, err);
  }
  else if (CONFIG_TYPE(he->type) == DT_NUMBER)
  {
    number_he_toggle(NeoMutt->sub, he, err);
  }
  else
  {
    buf_printf(err, _("Command '%s' can only be used with bool/quad variables"), "toggle");
    return MUTT_CMD_ERROR;
  }
  return MUTT_CMD_SUCCESS;
}

enum CommandResult command_set_query(struct Buffer *name, struct Buffer *err)
{
  ASSERT(name);
  // In the interactive case (outside of the initial parsing of neomuttrc) we
  // support additional syntax: "set" (no arguments) and "set all".
  // If not in interactive mode, we recognise them but do nothing.
 
  // Handle "set" (no arguments), i.e. show list of changed variables.
  if (buf_is_empty(name))
  {
    if (StartupComplete)
      return set_dump(GEL_CHANGED_CONFIG, err);
    else
      return MUTT_CMD_SUCCESS;
  }
  // Handle special "set all" syntax
  if (mutt_str_equal(name->data, "all"))
  {
    if (StartupComplete)
      return set_dump(GEL_ALL_CONFIG, err);
    else
      return MUTT_CMD_SUCCESS;
  }
 
  struct HashElem *he = cs_subset_lookup(NeoMutt->sub, name->data);
  if (!he)
  {
    buf_printf(err, _("Unknown option %s"), name->data);
    return MUTT_CMD_ERROR;
  }
 
  if (he->type & D_INTERNAL_DEPRECATED)
  {
    mutt_warning(_("Option %s is deprecated"), name->data);
    return MUTT_CMD_SUCCESS;
  }
 
  buf_addstr(err, name->data);
  buf_addch(err, '=');
  struct Buffer *value = buf_pool_get();
  int rc = cs_subset_he_string_get(NeoMutt->sub, he, value);
  if (CSR_RESULT(rc) != CSR_SUCCESS)
  {
    // LCOV_EXCL_START
    buf_reset(err);
    buf_addstr(err, value->data);
    buf_pool_release(&value);
    return MUTT_CMD_ERROR;
    // LCOV_EXCL_STOP
  }
  if (CONFIG_TYPE(he->type) == DT_PATH)
    pretty_mailbox(value);
  pretty_var(value->data, err);
  buf_pool_release(&value);
 
  return MUTT_CMD_SUCCESS;
}

enum CommandResult parse_set(const struct Command *cmd, struct Buffer *line,
                             const struct ParseContext *pc, struct ParseError *pe)
{
  struct Buffer *err = pe->message;
 
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_WARNING;
 
  do
  {
    bool prefix = false;
    bool query = false;
    bool inv = (cmd->id == CMD_TOGGLE);
    bool reset = (cmd->id == CMD_RESET);
    bool unset = (cmd->id == CMD_UNSET);
 
    if (*line->dptr == '?')
    {
      prefix = true;
      query = true;
      line->dptr++;
    }
    else if (mutt_str_startswith(line->dptr, "no"))
    {
      prefix = true;
      unset = !unset;
      line->dptr += 2;
    }
    else if (mutt_str_startswith(line->dptr, "inv"))
    {
      prefix = true;
      inv = !inv;
      line->dptr += 3;
    }
    else if (*line->dptr == '&')
    {
      prefix = true;
      reset = true;
      line->dptr++;
    }
 
    if (prefix && (cmd->id != CMD_SET))
    {
      buf_printf(err, _("Can't use 'inv', 'no', '&' or '?' with the '%s' command"),
                 cmd->name);
      goto done;
    }
 
    // get the variable name.  Note that token might be empty if no additional
    // argument was given.
    int ret = parse_extract_token(token, line,
                                  TOKEN_EQUAL | TOKEN_QUESTION | TOKEN_PLUS | TOKEN_MINUS);
    if (ret == -1)
    {
      buf_pool_release(&token);
      return MUTT_CMD_ERROR;
    }
 
    bool bool_or_quad = false;
    bool invertible = false;
    bool equals = false;
    bool increment = false;
    bool decrement = false;
 
    struct HashElem *he = cs_subset_lookup(NeoMutt->sub, buf_string(token));
    if (he)
    {
      // Use the correct name if a synonym is used
      buf_strcpy(token, he->key.strkey);
      bool_or_quad = ((CONFIG_TYPE(he->type) == DT_BOOL) ||
                      (CONFIG_TYPE(he->type) == DT_QUAD));
      invertible = (bool_or_quad || (CONFIG_TYPE(he->type) == DT_NUMBER));
    }
 
    if (*line->dptr == '?')
    {
      if (prefix)
      {
        buf_printf(err, _("Can't use a prefix when querying a variable"));
        goto done;
      }
 
      if (reset || unset || inv)
      {
        buf_printf(err, _("Can't query option with the '%s' command"), cmd->name);
        goto done;
      }
 
      query = true;
      line->dptr++;
    }
    else if ((*line->dptr == '+') || (*line->dptr == '-'))
    {
      if (prefix)
      {
        buf_printf(err, _("Can't use prefix when incrementing or decrementing a variable"));
        goto done;
      }
 
      if (reset || unset || inv)
      {
        buf_printf(err, _("Can't set option with the '%s' command"), cmd->name);
        goto done;
      }
      if (*line->dptr == '+')
        increment = true;
      else
        decrement = true;
 
      line->dptr++;
      if (*line->dptr == '=')
      {
        equals = true;
        line->dptr++;
      }
      else
      {
        buf_printf(err, _("'+' and '-' must be followed by '='"));
        goto done;
      }
    }
    else if (*line->dptr == '=')
    {
      if (prefix)
      {
        buf_printf(err, _("Can't use prefix when setting a variable"));
        goto done;
      }
 
      if (reset || unset || inv)
      {
        buf_printf(err, _("Can't set option with the '%s' command"), cmd->name);
        goto done;
      }
 
      equals = true;
      line->dptr++;
    }
 
    if (!invertible && (inv || (unset && prefix)))
    {
      if (cmd->id == CMD_SET)
      {
        buf_printf(err, _("Prefixes 'no' and 'inv' may only be used with bool/quad/number variables"));
      }
      else
      {
        buf_printf(err, _("Command '%s' can only be used with bool/quad/number variables"),
                   cmd->name);
      }
      goto done;
    }
 
    // sanity checks for the above
    // Each of inv, unset reset, query, equals implies that the others are not set.
    // If none of them are set, then we are dealing with a "set foo" command.
    // clang-format off
    ASSERT(!inv    || !(       unset || reset || query || equals          ));
    ASSERT(!unset  || !(inv ||          reset || query || equals          ));
    ASSERT(!reset  || !(inv || unset ||          query || equals          ));
    ASSERT(!query  || !(inv || unset || reset ||          equals          ));
    ASSERT(!equals || !(inv || unset || reset || query ||           prefix));
    // clang-format on
    ASSERT(!(increment && decrement)); // only one of increment or decrement is set
    ASSERT(!(increment || decrement) || equals); // increment/decrement implies equals
    ASSERT(!inv || invertible); // inv (aka toggle) implies bool or quad
 
    rc = MUTT_CMD_ERROR;
    if (query)
    {
      rc = command_set_query(token, err);
      goto done; // We can only do one query even if multiple config names are given
    }
    else if (reset)
    {
      rc = command_set_reset(token, err);
    }
    else if (unset)
    {
      rc = command_set_unset(token, err);
    }
    else if (inv)
    {
      rc = command_set_toggle(token, err);
    }
    else if (equals)
    {
      // These three cases all need a value, since 'increment'/'decrement'
      // implies 'equals', we can group them in this single case guarded by
      // 'equals'.
      struct Buffer *value = buf_pool_get();
      parse_extract_token(value, line, TOKEN_BACKTICK_VARS);
      if (increment)
        rc = command_set_increment(token, value, err);
      else if (decrement)
        rc = command_set_decrement(token, value, err);
      else
        rc = command_set_set(token, value, err);
      buf_pool_release(&value);
    }
    else
    {
      // This is the "set foo" case which has different meanings depending on
      // the type of the config variable
      if (bool_or_quad)
      {
        struct Buffer *yes = buf_pool_get();
        buf_addstr(yes, "yes");
        rc = command_set_set(token, yes, err);
        buf_pool_release(&yes);
      }
      else
      {
        rc = command_set_query(token, err);
        goto done; // We can only do one query even if multiple config names are given
      }
    }
    // Short circuit (i.e. skipping further config variable names) if the action on
    // the current variable failed.
    if (rc != MUTT_CMD_SUCCESS)
      goto done;
  } while (MoreArgs(line));
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  return rc;
}