Set a config item by string. More...

Collaboration diagram for string_set():

Functions
static int	address_string_set (void var, struct ConfigDef cdef, const char value, struct Buffer err)
	Set an Address by string - Implements ConfigSetType::string_set() -.

static int	bool_string_set (void var, struct ConfigDef cdef, const char value, struct Buffer err)
	Set a Bool by string - Implements ConfigSetType::string_set() -.

static int	enum_string_set (void var, struct ConfigDef cdef, const char value, struct Buffer err)
	Set an Enumeration by string - Implements ConfigSetType::string_set() -.

static int	long_string_set (void var, struct ConfigDef cdef, const char value, struct Buffer err)
	Set a Long by string - Implements ConfigSetType::string_set() -.

static int	mbtable_string_set (void var, struct ConfigDef cdef, const char value, struct Buffer err)
	Set an MbTable by string - Implements ConfigSetType::string_set() -.

static int	myvar_string_set (void var, struct ConfigDef cdef, const char value, struct Buffer err)
	Set a MyVar by string - Implements ConfigSetType::string_set() -.

static int	number_string_set (void var, struct ConfigDef cdef, const char value, struct Buffer err)
	Set a Number by string - Implements ConfigSetType::string_set() -.

static int	path_string_set (void var, struct ConfigDef cdef, const char value, struct Buffer err)
	Set a Path by string - Implements ConfigSetType::string_set() -.

static int	quad_string_set (void var, struct ConfigDef cdef, const char value, struct Buffer err)
	Set a Quad-option by string - Implements ConfigSetType::string_set() -.

static int	regex_string_set (void var, struct ConfigDef cdef, const char value, struct Buffer err)
	Set a Regex by string - Implements ConfigSetType::string_set() -.

static int	slist_string_set (void var, struct ConfigDef cdef, const char value, struct Buffer err)
	Set a Slist by string - Implements ConfigSetType::string_set() -.

static int	sort_string_set (void var, struct ConfigDef cdef, const char value, struct Buffer err)
	Set a Sort by string - Implements ConfigSetType::string_set() -.

static int	string_string_set (void var, struct ConfigDef cdef, const char value, struct Buffer err)
	Set a String by string - Implements ConfigSetType::string_set() -.

static int	expando_string_set (void var, struct ConfigDef cdef, const char value, struct Buffer err)
	Set an Expando by string - Implements ConfigSetType::string_set() -.

Detailed Description

Set a config item by string.

Parameters

var	Variable to set (may be NULL)
cdef	Variable definition
value	Value to set (may be NULL)
err	Buffer for error messages (may be NULL)

Return values

num	Result, e.g. CSR_SUCCESS

If var is NULL, then the config item's initial value will be set.

Precondition: cdef is not NULL

Function Documentation

◆ address_string_set()

static int address_string_set	(	void *	var,
		struct ConfigDef *	cdef,
		const char *	value,
		struct Buffer *	err )

static

Set an Address by string - Implements ConfigSetType::string_set() -.

Definition at line 74 of file config_type.c.

{
  /* Store empty address as NULL */
  if (value && (value[0] == '\0'))
    value = NULL;
 
  struct Address *addr = NULL;
 
  int rc = CSR_SUCCESS;
 
  if (!value && (cdef->type & D_NOT_EMPTY))
  {
    buf_printf(err, _("Option %s may not be empty"), cdef->name);
    return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
  }
 
  if (var && value)
  {
    // TODO - config can only store one
    struct AddressList al = TAILQ_HEAD_INITIALIZER(al);
    mutt_addrlist_parse(&al, value);
    addr = mutt_addr_copy(TAILQ_FIRST(&al));
    mutt_addrlist_clear(&al);
  }
 
  if (var)
  {
    if (cdef->validator)
    {
      rc = cdef->validator(cdef, (intptr_t) addr, err);
 
      if (CSR_RESULT(rc) != CSR_SUCCESS)
      {
        address_destroy(&addr, cdef);
        return rc | CSR_INV_VALIDATOR;
      }
    }
 
    /* ordinary variable setting */
    address_destroy(var, cdef);
 
    *(struct Address **) var = addr;
 
    if (!addr)
      rc |= CSR_SUC_EMPTY;
  }
  else
  {
    /* set the default/initial value */
    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;
}

Here is the call graph for this function:

◆ bool_string_set()

static int bool_string_set	(	void *	var,
		struct ConfigDef *	cdef,
		const char *	value,
		struct Buffer *	err )

static

Set a Bool by string - Implements ConfigSetType::string_set() -.

Definition at line 58 of file bool.c.

{
  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 boolean value: %s"), value);
    return CSR_ERR_INVALID | CSR_INV_TYPE;
  }
 
  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;
}

Here is the call graph for this function:

◆ enum_string_set()

static int enum_string_set	(	void *	var,
		struct ConfigDef *	cdef,
		const char *	value,
		struct Buffer *	err )

static

Set an Enumeration by string - Implements ConfigSetType::string_set() -.

Definition at line 45 of file enum.c.

{
  if (!value)
    return CSR_ERR_CODE; /* LCOV_EXCL_LINE */
 
  struct EnumDef *ed = (struct EnumDef *) cdef->data;
  if (!ed || !ed->lookup)
    return CSR_ERR_CODE;
 
  int num = mutt_map_get_value(value, ed->lookup);
  if (num < 0)
  {
    buf_printf(err, _("Invalid enum value: %s"), value);
    return CSR_ERR_INVALID | CSR_INV_TYPE;
  }
 
  if (var)
  {
    if (num == (*(unsigned char *) 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;
    }
 
    *(unsigned char *) var = num;
  }
  else
  {
    cdef->initial = num;
  }
 
  return CSR_SUCCESS;
}

Here is the call graph for this function:

◆ long_string_set()

static int long_string_set	(	void *	var,
		struct ConfigDef *	cdef,
		const char *	value,
		struct Buffer *	err )

static

Set a Long by string - Implements ConfigSetType::string_set() -.

Definition at line 46 of file long.c.

{
  if (!value || (value[0] == '\0'))
  {
    buf_printf(err, _("Option %s may not be empty"), cdef->name);
    return CSR_ERR_INVALID | CSR_INV_TYPE;
  }
 
  long num = 0;
  if (!mutt_str_atol_full(value, &num))
  {
    buf_printf(err, _("Invalid long: %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 == (*(long *) 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;
    }
 
    *(long *) var = num;
  }
  else
  {
    cdef->initial = num;
  }
 
  return CSR_SUCCESS;
}

Here is the call graph for this function:

◆ mbtable_string_set()

static int mbtable_string_set	(	void *	var,
		struct ConfigDef *	cdef,
		const char *	value,
		struct Buffer *	err )

static

Set an MbTable by string - Implements ConfigSetType::string_set() -.

Definition at line 122 of file mbtable.c.

{
  /* 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(cdef, (intptr_t) table, err);
 
      if (CSR_RESULT(rc) != CSR_SUCCESS)
      {
        mbtable_free(&table);
        return rc | CSR_INV_VALIDATOR;
      }
    }
 
    mbtable_destroy(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;
}

Here is the call graph for this function:

◆ myvar_string_set()

static int myvar_string_set	(	void *	var,
		struct ConfigDef *	cdef,
		const char *	value,
		struct Buffer *	err )

static

Set a MyVar by string - Implements ConfigSetType::string_set() -.

Definition at line 57 of file myvar.c.

{
  /* Store empty myvars as NULL */
  if (value && (value[0] == '\0'))
    value = NULL;
 
  int rc = CSR_SUCCESS;
 
  if (var)
  {
    if (mutt_str_equal(value, (*(char **) var)))
      return CSR_SUCCESS | CSR_SUC_NO_CHANGE;
 
    myvar_destroy(var, cdef);
 
    const char *str = mutt_str_dup(value);
    if (!str)
      rc |= CSR_SUC_EMPTY;
 
    *(const char **) var = str;
  }
  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;
}

Here is the call graph for this function:

◆ number_string_set()

static int number_string_set	(	void *	var,
		struct ConfigDef *	cdef,
		const char *	value,
		struct Buffer *	err )

static

Set a Number by string - Implements ConfigSetType::string_set() -.

Definition at line 79 of file number.c.

{
  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(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;
}

Here is the call graph for this function:

◆ path_string_set()

static int path_string_set	(	void *	var,
		struct ConfigDef *	cdef,
		const char *	value,
		struct Buffer *	err )

static

Set a Path by string - Implements ConfigSetType::string_set() -.

Definition at line 89 of file path.c.

{
  /* Store empty paths as NULL */
  if (value && (value[0] == '\0'))
    value = NULL;
 
  if (!value && (cdef->type & D_NOT_EMPTY))
  {
    buf_printf(err, _("Option %s may not be empty"), cdef->name);
    return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
  }
 
  int rc = CSR_SUCCESS;
 
  if (var)
  {
    if (mutt_str_equal(value, (*(char **) var)))
      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(cdef, (intptr_t) value, err);
 
      if (CSR_RESULT(rc) != CSR_SUCCESS)
        return rc | CSR_INV_VALIDATOR;
    }
 
    path_destroy(var, cdef);
 
    const char *str = path_tidy(value, cdef->type & D_PATH_DIR);
    if (!str)
      rc |= CSR_SUC_EMPTY;
 
    *(const char **) var = str;
  }
  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;
}

Here is the call graph for this function:

◆ quad_string_set()

static int quad_string_set	(	void *	var,
		struct ConfigDef *	cdef,
		const char *	value,
		struct Buffer *	err )

static

Set a Quad-option by string - Implements ConfigSetType::string_set() -.

Definition at line 61 of file quad.c.

{
  if (!value)
    return CSR_ERR_CODE; /* LCOV_EXCL_LINE */
 
  int num = -1;
  for (size_t i = 0; QuadValues[i]; i++)
  {
    if (mutt_istr_equal(QuadValues[i], value))
    {
      num = i;
      break;
    }
  }
 
  if (num < 0)
  {
    buf_printf(err, _("Invalid quad value: %s"), value);
    return CSR_ERR_INVALID | CSR_INV_TYPE;
  }
 
  if (var)
  {
    if (num == (*(char *) 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;
    }
 
    *(char *) var = num;
  }
  else
  {
    cdef->initial = num;
  }
 
  return CSR_SUCCESS;
}

Here is the call graph for this function:

◆ regex_string_set()

static int regex_string_set	(	void *	var,
		struct ConfigDef *	cdef,
		const char *	value,
		struct Buffer *	err )

static

Set a Regex by string - Implements ConfigSetType::string_set() -.

Definition at line 142 of file regex.c.

{
  /* Store empty regexes as NULL */
  if (value && (value[0] == '\0'))
    value = NULL;
 
  struct Regex *r = NULL;
 
  int rc = CSR_SUCCESS;
 
  if (var)
  {
    struct Regex *curval = *(struct Regex **) var;
    if (curval && mutt_str_equal(value, curval->pattern))
      return CSR_SUCCESS | CSR_SUC_NO_CHANGE;
 
    if (startup_only(cdef, err))
      return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
 
    if (value)
    {
      r = regex_new(value, cdef->type, err);
      if (!r)
        return CSR_ERR_INVALID;
    }
 
    if (cdef->validator)
    {
      rc = cdef->validator(cdef, (intptr_t) r, err);
 
      if (CSR_RESULT(rc) != CSR_SUCCESS)
      {
        regex_free(&r);
        return rc | CSR_INV_VALIDATOR;
      }
    }
 
    regex_destroy(var, cdef);
 
    *(struct Regex **) var = r;
 
    if (!r)
      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;
}

Here is the call graph for this function:

◆ slist_string_set()

static int slist_string_set	(	void *	var,
		struct ConfigDef *	cdef,
		const char *	value,
		struct Buffer *	err )

static

Set a Slist by string - Implements ConfigSetType::string_set() -.

Definition at line 59 of file slist.c.

{
  /* Store empty string list as NULL */
  if (value && (value[0] == '\0'))
    value = NULL;
 
  struct Slist *list = NULL;
 
  int rc = CSR_SUCCESS;
 
  if (var)
  {
    list = slist_parse(value, cdef->type);
 
    if (slist_equal(list, *(struct Slist **) var))
    {
      slist_free(&list);
      return CSR_SUCCESS | CSR_SUC_NO_CHANGE;
    }
 
    if (startup_only(cdef, err))
    {
      slist_free(&list);
      return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
    }
 
    if (cdef->validator)
    {
      rc = cdef->validator(cdef, (intptr_t) list, err);
 
      if (CSR_RESULT(rc) != CSR_SUCCESS)
      {
        slist_free(&list);
        return rc | CSR_INV_VALIDATOR;
      }
    }
 
    slist_destroy(var, cdef);
 
    *(struct Slist **) var = list;
 
    if (!list)
      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;
}

Here is the call graph for this function:

◆ sort_string_set()

static int sort_string_set	(	void *	var,
		struct ConfigDef *	cdef,
		const char *	value,
		struct Buffer *	err )

static

Set a Sort by string - Implements ConfigSetType::string_set() -.

Definition at line 50 of file sort.c.

{
  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 sort name: %s"), value);
    return CSR_ERR_INVALID | CSR_INV_TYPE;
  }
 
  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;
}

Here is the call graph for this function:

◆ string_string_set()

static int string_string_set	(	void *	var,
		struct ConfigDef *	cdef,
		const char *	value,
		struct Buffer *	err )

static

Set a String by string - Implements ConfigSetType::string_set() -.

Definition at line 60 of file string.c.

{
  /* Store empty strings as NULL */
  if (value && (value[0] == '\0'))
    value = NULL;
 
  if (!value && (cdef->type & D_NOT_EMPTY))
  {
    buf_printf(err, _("Option %s may not be empty"), cdef->name);
    return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
  }
 
  int rc = CSR_SUCCESS;
 
  if (var)
  {
    if (mutt_str_equal(value, (*(char **) var)))
      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(cdef, (intptr_t) value, err);
 
      if (CSR_RESULT(rc) != CSR_SUCCESS)
        return rc | CSR_INV_VALIDATOR;
    }
 
    string_destroy(var, cdef);
 
    const char *str = mutt_str_dup(value);
    if (!str)
      rc |= CSR_SUC_EMPTY;
 
    *(const char **) var = str;
  }
  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;
}

Here is the call graph for this function:

◆ expando_string_set()

static int expando_string_set	(	void *	var,
		struct ConfigDef *	cdef,
		const char *	value,
		struct Buffer *	err )

static

Set an Expando by string - Implements ConfigSetType::string_set() -.

Definition at line 61 of file config_type.c.

{
  /* Store empty string list as NULL */
  if (value && (value[0] == '\0'))
    value = NULL;
 
  if (!value && (cdef->type & D_NOT_EMPTY))
  {
    buf_printf(err, _("Option %s may not be empty"), cdef->name);
    return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
  }
 
  int rc = CSR_SUCCESS;
 
  if (var)
  {
    const struct ExpandoDefinition *defs = (const struct ExpandoDefinition *)
                                               cdef->data;
    struct Expando *exp = expando_parse(value, defs, err);
    if (!exp && !buf_is_empty(err))
    {
      char opt[128] = { 0 };
      // L10N: e.g. "Option index_format:" plus an error message
      snprintf(opt, sizeof(opt), _("Option %s: "), cdef->name);
      buf_insert(err, 0, opt);
      return CSR_ERR_INVALID;
    }
 
    if (expando_equal(exp, *(struct Expando **) var))
    {
      expando_free(&exp);
      return CSR_SUCCESS | CSR_SUC_NO_CHANGE;
    }
 
    if (startup_only(cdef, err))
    {
      expando_free(&exp);
      return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
    }
 
    if (cdef->validator)
    {
      rc = cdef->validator(cdef, (intptr_t) exp, err);
 
      if (CSR_RESULT(rc) != CSR_SUCCESS)
      {
        expando_free(&exp);
        return rc | CSR_INV_VALIDATOR;
      }
    }
 
    expando_destroy(var, cdef);
 
    *(struct Expando **) var = exp;
 
    if (!exp)
      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;
}

Here is the call graph for this function:

Functions

Detailed Description

Function Documentation

◆ address_string_set()

◆ bool_string_set()

◆ enum_string_set()

◆ long_string_set()

◆ mbtable_string_set()

◆ myvar_string_set()

◆ number_string_set()

◆ path_string_set()

◆ quad_string_set()

◆ regex_string_set()

◆ slist_string_set()

◆ sort_string_set()

◆ string_string_set()

◆ expando_string_set()