NeoMutt  2023-05-17-56-ga67199
Teaching an old dog new tricks
 		DOXYGEN
Functions
string_set()
Config Type API

Set a config item by string. More...

+ Collaboration diagram for string_set():

Functions

static int address_string_set (const struct ConfigSet *cs, void *var, struct ConfigDef *cdef, const char *value, struct Buffer *err)
 Set an Address by string - Implements ConfigSetType::string_set() -. More...
 
static int bool_string_set (const struct ConfigSet *cs, void *var, struct ConfigDef *cdef, const char *value, struct Buffer *err)
 Set a Bool by string - Implements ConfigSetType::string_set() -. More...
 
static int enum_string_set (const struct ConfigSet *cs, void *var, struct ConfigDef *cdef, const char *value, struct Buffer *err)
 Set an Enumeration by string - Implements ConfigSetType::string_set() -. More...
 
static int long_string_set (const struct ConfigSet *cs, void *var, struct ConfigDef *cdef, const char *value, struct Buffer *err)
 Set a Long by string - Implements ConfigSetType::string_set() -. More...
 
static int mbtable_string_set (const struct ConfigSet *cs, void *var, struct ConfigDef *cdef, const char *value, struct Buffer *err)
 Set an MbTable by string - Implements ConfigSetType::string_set() -. More...
 
static int myvar_string_set (const struct ConfigSet *cs, void *var, struct ConfigDef *cdef, const char *value, struct Buffer *err)
 Set a MyVar by string - Implements ConfigSetType::string_set() -. More...
 
static int number_string_set (const struct ConfigSet *cs, void *var, struct ConfigDef *cdef, const char *value, struct Buffer *err)
 Set a Number by string - Implements ConfigSetType::string_set() -. More...
 
static int path_string_set (const struct ConfigSet *cs, void *var, struct ConfigDef *cdef, const char *value, struct Buffer *err)
 Set a Path by string - Implements ConfigSetType::string_set() -. More...
 
static int quad_string_set (const struct ConfigSet *cs, void *var, struct ConfigDef *cdef, const char *value, struct Buffer *err)
 Set a Quad-option by string - Implements ConfigSetType::string_set() -. More...
 
static int regex_string_set (const struct ConfigSet *cs, void *var, struct ConfigDef *cdef, const char *value, struct Buffer *err)
 Set a Regex by string - Implements ConfigSetType::string_set() -. More...
 
static int slist_string_set (const struct ConfigSet *cs, void *var, struct ConfigDef *cdef, const char *value, struct Buffer *err)
 Set a Slist by string - Implements ConfigSetType::string_set() -. More...
 
static int sort_string_set (const struct ConfigSet *cs, void *var, struct ConfigDef *cdef, const char *value, struct Buffer *err)
 Set a Sort by string - Implements ConfigSetType::string_set() -. More...
 
static int string_string_set (const struct ConfigSet *cs, void *var, struct ConfigDef *cdef, const char *value, struct Buffer *err)
 Set a String by string - Implements ConfigSetType::string_set() -. More...
 

Detailed Description

Set a config item by string.

Parameters
csConfig items
varVariable to set (may be NULL)
cdefVariable definition
valueValue to set (may be NULL)
errBuffer for error messages (may be NULL)
Return values
numResult, e.g. CSR_SUCCESS

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

Precondition
cs is not NULL
cdef is not NULL

Function Documentation

◆ address_string_set()

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

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

Definition at line 61 of file address.c.

63{
64 struct Address *addr = NULL;
65
66 /* An empty address "" will be stored as NULL */
67 if (var && value && (value[0] != '\0'))
68 {
69 // TODO - config can only store one
70 struct AddressList al = TAILQ_HEAD_INITIALIZER(al);
71 mutt_addrlist_parse(&al, value);
72 addr = mutt_addr_copy(TAILQ_FIRST(&al));
73 mutt_addrlist_clear(&al);
74 }
75
76 int rc = CSR_SUCCESS;
77
78 if (var)
79 {
80 if (cdef->validator)
81 {
82 rc = cdef->validator(cs, cdef, (intptr_t) addr, err);
83
84 if (CSR_RESULT(rc) != CSR_SUCCESS)
85 {
86 address_destroy(cs, &addr, cdef);
87 return rc | CSR_INV_VALIDATOR;
88 }
89 }
90
91 /* ordinary variable setting */
92 address_destroy(cs, var, cdef);
93
94 *(struct Address **) var = addr;
95
96 if (!addr)
97 rc |= CSR_SUC_EMPTY;
98 }
99 else
100 {
101 /* set the default/initial value */
102 if (cdef->type & DT_INITIAL_SET)
103 FREE(&cdef->initial);
104
105 cdef->type |= DT_INITIAL_SET;
106 cdef->initial = (intptr_t) mutt_str_dup(value);
107 }
108
109 return rc;
110}
mutt_addrlist_clear
void mutt_addrlist_clear(struct AddressList *al)
Unlink and free all Address in an AddressList.
Definition: address.c:1449
mutt_addr_copy
struct Address * mutt_addr_copy(const struct Address *addr)
Copy the real address.
Definition: address.c:730
mutt_addrlist_parse
int mutt_addrlist_parse(struct AddressList *al, const char *s)
Parse a list of email addresses.
Definition: address.c:472
CSR_INV_VALIDATOR
#define CSR_INV_VALIDATOR
Value was rejected by the validator.
Definition: set.h:48
CSR_RESULT
#define CSR_RESULT(x)
Definition: set.h:52
CSR_SUC_EMPTY
#define CSR_SUC_EMPTY
Value is empty/unset.
Definition: set.h:42
CSR_SUCCESS
#define CSR_SUCCESS
Action completed successfully.
Definition: set.h:35
address_destroy
static void address_destroy(const struct ConfigSet *cs, void *var, const struct ConfigDef *cdef)
Destroy an Address object - Implements ConfigSetType::destroy() -.
Definition: address.c:49
FREE
#define FREE(x)
Definition: memory.h:43
mutt_str_dup
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:251
TAILQ_FIRST
#define TAILQ_FIRST(head)
Definition: queue.h:723
TAILQ_HEAD_INITIALIZER
#define TAILQ_HEAD_INITIALIZER(head)
Definition: queue.h:637
Address
An email address.
Definition: address.h:36
ConfigDef::validator
int(* validator)(const struct ConfigSet *cs, const struct ConfigDef *cdef, intptr_t value, struct Buffer *err)
Definition: set.h:82
ConfigDef::initial
intptr_t initial
Initial value.
Definition: set.h:67
ConfigDef::type
uint32_t type
Variable type, e.g. DT_STRING.
Definition: set.h:66
DT_INITIAL_SET
#define DT_INITIAL_SET
Config item must have its initial value freed.
Definition: types.h:79
+ Here is the call graph for this function:

◆ bool_string_set()

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

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

Definition at line 57 of file bool.c.

59{
60 if (!value)
61 return CSR_ERR_CODE; /* LCOV_EXCL_LINE */
62
63 int num = -1;
64 for (size_t i = 0; BoolValues[i]; i++)
65 {
66 if (mutt_istr_equal(BoolValues[i], value))
67 {
68 num = i % 2;
69 break;
70 }
71 }
72
73 if (num < 0)
74 {
75 buf_printf(err, _("Invalid boolean value: %s"), value);
76 return CSR_ERR_INVALID | CSR_INV_TYPE;
77 }
78
79 if (var)
80 {
81 if (num == (*(bool *) var))
82 return CSR_SUCCESS | CSR_SUC_NO_CHANGE;
83
84 if (cdef->validator)
85 {
86 int rc = cdef->validator(cs, cdef, (intptr_t) num, err);
87
88 if (CSR_RESULT(rc) != CSR_SUCCESS)
89 return rc | CSR_INV_VALIDATOR;
90 }
91
92 *(bool *) var = num;
93 }
94 else
95 {
96 cdef->initial = num;
97 }
98
99 return CSR_SUCCESS;
100}
BoolValues
const char * BoolValues[]
Valid strings for creating a Bool.
Definition: bool.c:50
buf_printf
int buf_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:173
CSR_ERR_INVALID
#define CSR_ERR_INVALID
Value hasn't been set.
Definition: set.h:38
CSR_INV_TYPE
#define CSR_INV_TYPE
Value is not valid for the type.
Definition: set.h:47
CSR_SUC_NO_CHANGE
#define CSR_SUC_NO_CHANGE
The value hasn't changed.
Definition: set.h:44
CSR_ERR_CODE
#define CSR_ERR_CODE
Problem with the code.
Definition: set.h:36
_
#define _(a)
Definition: message.h:28
mutt_istr_equal
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:810
+ Here is the call graph for this function:

◆ enum_string_set()

static int enum_string_set ( const struct ConfigSet *  cs,
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.

47{
48 if (!cs || !cdef || !value)
49 return CSR_ERR_CODE; /* LCOV_EXCL_LINE */
50
51 struct EnumDef *ed = (struct EnumDef *) cdef->data;
52 if (!ed || !ed->lookup)
53 return CSR_ERR_CODE;
54
55 int num = mutt_map_get_value(value, ed->lookup);
56 if (num < 0)
57 {
58 buf_printf(err, _("Invalid enum value: %s"), value);
59 return CSR_ERR_INVALID | CSR_INV_TYPE;
60 }
61
62 if (var)
63 {
64 if (num == (*(unsigned char *) var))
65 return CSR_SUCCESS | CSR_SUC_NO_CHANGE;
66
67 if (cdef->validator)
68 {
69 int rc = cdef->validator(cs, cdef, (intptr_t) num, err);
70
71 if (CSR_RESULT(rc) != CSR_SUCCESS)
72 return rc | CSR_INV_VALIDATOR;
73 }
74
75 *(unsigned char *) var = num;
76 }
77 else
78 {
79 cdef->initial = num;
80 }
81
82 return CSR_SUCCESS;
83}
mutt_map_get_value
int mutt_map_get_value(const char *name, const struct Mapping *map)
Lookup the constant for a string.
Definition: mapping.c:85
ConfigDef::data
intptr_t data
Extra variable data.
Definition: set.h:68
EnumDef
An enumeration.
Definition: enum.h:30
EnumDef::lookup
struct Mapping * lookup
Lookup table.
Definition: enum.h:33
+ Here is the call graph for this function:

◆ long_string_set()

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

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

Definition at line 43 of file long.c.

45{
46 if (!value || (value[0] == '\0'))
47 {
48 buf_printf(err, _("Option %s may not be empty"), cdef->name);
49 return CSR_ERR_INVALID | CSR_INV_TYPE;
50 }
51
52 long num = 0;
53 if (!mutt_str_atol_full(value, &num))
54 {
55 buf_printf(err, _("Invalid long: %s"), value);
56 return CSR_ERR_INVALID | CSR_INV_TYPE;
57 }
58
59 if ((num < 0) && (cdef->type & DT_NOT_NEGATIVE))
60 {
61 buf_printf(err, _("Option %s may not be negative"), cdef->name);
62 return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
63 }
64
65 if (var)
66 {
67 if (num == (*(long *) var))
68 return CSR_SUCCESS | CSR_SUC_NO_CHANGE;
69
70 if (cdef->validator)
71 {
72 int rc = cdef->validator(cs, cdef, (intptr_t) num, err);
73
74 if (CSR_RESULT(rc) != CSR_SUCCESS)
75 return rc | CSR_INV_VALIDATOR;
76 }
77
78 *(long *) var = num;
79 }
80 else
81 {
82 cdef->initial = num;
83 }
84
85 return CSR_SUCCESS;
86}
ConfigDef::name
const char * name
User-visible name.
Definition: set.h:65
DT_NOT_NEGATIVE
#define DT_NOT_NEGATIVE
Negative numbers are not allowed.
Definition: types.h:50
+ Here is the call graph for this function:

◆ mbtable_string_set()

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

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

Definition at line 105 of file mbtable.c.

107{
108 /* Store empty mbtables as NULL */
109 if (value && (value[0] == '\0'))
110 value = NULL;
111
112 struct MbTable *table = NULL;
113
114 int rc = CSR_SUCCESS;
115
116 if (var)
117 {
118 struct MbTable *curval = *(struct MbTable **) var;
119 if (curval && mutt_str_equal(value, curval->orig_str))
120 return CSR_SUCCESS | CSR_SUC_NO_CHANGE;
121
122 table = mbtable_parse(value);
123
124 if (cdef->validator)
125 {
126 rc = cdef->validator(cs, cdef, (intptr_t) table, err);
127
128 if (CSR_RESULT(rc) != CSR_SUCCESS)
129 {
130 mbtable_free(&table);
131 return rc | CSR_INV_VALIDATOR;
132 }
133 }
134
135 mbtable_destroy(cs, var, cdef);
136
137 *(struct MbTable **) var = table;
138
139 if (!table)
140 rc |= CSR_SUC_EMPTY;
141 }
142 else
143 {
144 if (cdef->type & DT_INITIAL_SET)
145 FREE(&cdef->initial);
146
147 cdef->type |= DT_INITIAL_SET;
148 cdef->initial = (intptr_t) mutt_str_dup(value);
149 }
150
151 return rc;
152}
mbtable_destroy
static void mbtable_destroy(const struct ConfigSet *cs, void *var, const struct ConfigDef *cdef)
Destroy an MbTable object - Implements ConfigSetType::destroy() -.
Definition: mbtable.c:93
mbtable_free
void mbtable_free(struct MbTable **table)
Free an MbTable object.
Definition: mbtable.c:279
mbtable_parse
struct MbTable * mbtable_parse(const char *s)
Parse a multibyte string into a table.
Definition: mbtable.c:49
mutt_str_equal
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:798
MbTable
Multibyte character table.
Definition: mbtable.h:34
MbTable::orig_str
char * orig_str
Original string used to generate this object.
Definition: mbtable.h:35
+ Here is the call graph for this function:

◆ myvar_string_set()

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

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

Definition at line 53 of file myvar.c.

55{
56 /* Store empty myvars as NULL */
57 if (value && (value[0] == '\0'))
58 value = NULL;
59
60 int rc = CSR_SUCCESS;
61
62 if (var)
63 {
64 if (mutt_str_equal(value, (*(char **) var)))
65 return CSR_SUCCESS | CSR_SUC_NO_CHANGE;
66
67 myvar_destroy(cs, var, cdef);
68
69 const char *str = mutt_str_dup(value);
70 if (!str)
71 rc |= CSR_SUC_EMPTY;
72
73 *(const char **) var = str;
74 }
75 else
76 {
77 if (cdef->type & DT_INITIAL_SET)
78 FREE(&cdef->initial);
79
80 cdef->type |= DT_INITIAL_SET;
81 cdef->initial = (intptr_t) mutt_str_dup(value);
82 }
83
84 return rc;
85}
myvar_destroy
static void myvar_destroy(const struct ConfigSet *cs, void *var, const struct ConfigDef *cdef)
Destroy a MyVar - Implements ConfigSetType::destroy() -.
Definition: myvar.c:41
+ Here is the call graph for this function:

◆ number_string_set()

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

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

Definition at line 44 of file number.c.

46{
47 if (!value || (value[0] == '\0'))
48 {
49 buf_printf(err, _("Option %s may not be empty"), cdef->name);
50 return CSR_ERR_INVALID | CSR_INV_TYPE;
51 }
52
53 int num = 0;
54 if (!mutt_str_atoi_full(value, &num))
55 {
56 buf_printf(err, _("Invalid number: %s"), value);
57 return CSR_ERR_INVALID | CSR_INV_TYPE;
58 }
59
60 if ((num < SHRT_MIN) || (num > SHRT_MAX))
61 {
62 buf_printf(err, _("Number is too big: %s"), value);
63 return CSR_ERR_INVALID | CSR_INV_TYPE;
64 }
65
66 if ((num < 0) && (cdef->type & DT_NOT_NEGATIVE))
67 {
68 buf_printf(err, _("Option %s may not be negative"), cdef->name);
69 return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
70 }
71
72 if (var)
73 {
74 if (num == (*(short *) var))
75 return CSR_SUCCESS | CSR_SUC_NO_CHANGE;
76
77 if (cdef->validator)
78 {
79 int rc = cdef->validator(cs, cdef, (intptr_t) num, err);
80
81 if (CSR_RESULT(rc) != CSR_SUCCESS)
82 return rc | CSR_INV_VALIDATOR;
83 }
84
85 *(short *) var = num;
86 }
87 else
88 {
89 cdef->initial = num;
90 }
91
92 return CSR_SUCCESS;
93}
+ Here is the call graph for this function:

◆ path_string_set()

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

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

Definition at line 85 of file path.c.

87{
88 /* Store empty paths as NULL */
89 if (value && (value[0] == '\0'))
90 value = NULL;
91
92 if (!value && (cdef->type & DT_NOT_EMPTY))
93 {
94 buf_printf(err, _("Option %s may not be empty"), cdef->name);
95 return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
96 }
97
98 int rc = CSR_SUCCESS;
99
100 if (var)
101 {
102 if (mutt_str_equal(value, (*(char **) var)))
103 return CSR_SUCCESS | CSR_SUC_NO_CHANGE;
104
105 if (cdef->validator)
106 {
107 rc = cdef->validator(cs, cdef, (intptr_t) value, err);
108
109 if (CSR_RESULT(rc) != CSR_SUCCESS)
110 return rc | CSR_INV_VALIDATOR;
111 }
112
113 path_destroy(cs, var, cdef);
114
115 const char *str = path_tidy(value, cdef->type & DT_PATH_DIR);
116 if (!str)
117 rc |= CSR_SUC_EMPTY;
118
119 *(const char **) var = str;
120 }
121 else
122 {
123 if (cdef->type & DT_INITIAL_SET)
124 FREE(&cdef->initial);
125
126 cdef->type |= DT_INITIAL_SET;
127 cdef->initial = (intptr_t) mutt_str_dup(value);
128 }
129
130 return rc;
131}
path_tidy
static char * path_tidy(const char *path, bool is_dir)
Tidy a path for storage.
Definition: path.c:56
path_destroy
static void path_destroy(const struct ConfigSet *cs, void *var, const struct ConfigDef *cdef)
Destroy a Path - Implements ConfigSetType::destroy() -.
Definition: path.c:73
DT_PATH_DIR
#define DT_PATH_DIR
Path is a directory.
Definition: types.h:56
DT_NOT_EMPTY
#define DT_NOT_EMPTY
Empty strings are not allowed.
Definition: types.h:49
+ Here is the call graph for this function:

◆ quad_string_set()

static int quad_string_set ( const struct ConfigSet *  cs,
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 56 of file quad.c.

58{
59 if (!value)
60 return CSR_ERR_CODE; /* LCOV_EXCL_LINE */
61
62 int num = -1;
63 for (size_t i = 0; QuadValues[i]; i++)
64 {
65 if (mutt_istr_equal(QuadValues[i], value))
66 {
67 num = i;
68 break;
69 }
70 }
71
72 if (num < 0)
73 {
74 buf_printf(err, _("Invalid quad value: %s"), value);
75 return CSR_ERR_INVALID | CSR_INV_TYPE;
76 }
77
78 if (var)
79 {
80 if (num == (*(char *) var))
81 return CSR_SUCCESS | CSR_SUC_NO_CHANGE;
82
83 if (cdef->validator)
84 {
85 int rc = cdef->validator(cs, cdef, (intptr_t) num, err);
86
87 if (CSR_RESULT(rc) != CSR_SUCCESS)
88 return rc | CSR_INV_VALIDATOR;
89 }
90
91 *(char *) var = num;
92 }
93 else
94 {
95 cdef->initial = num;
96 }
97
98 return CSR_SUCCESS;
99}
QuadValues
const char * QuadValues[]
Valid strings for creating a QuadValue.
Definition: quad.c:49
+ Here is the call graph for this function:

◆ regex_string_set()

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

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

Definition at line 120 of file regex.c.

122{
123 /* Store empty regexes as NULL */
124 if (value && (value[0] == '\0'))
125 value = NULL;
126
127 struct Regex *r = NULL;
128
129 int rc = CSR_SUCCESS;
130
131 if (var)
132 {
133 struct Regex *curval = *(struct Regex **) var;
134 if (curval && mutt_str_equal(value, curval->pattern))
135 return CSR_SUCCESS | CSR_SUC_NO_CHANGE;
136
137 if (value)
138 {
139 r = regex_new(value, cdef->type, err);
140 if (!r)
141 return CSR_ERR_INVALID;
142 }
143
144 if (cdef->validator)
145 {
146 rc = cdef->validator(cs, cdef, (intptr_t) r, err);
147
148 if (CSR_RESULT(rc) != CSR_SUCCESS)
149 {
150 regex_free(&r);
151 return rc | CSR_INV_VALIDATOR;
152 }
153 }
154
155 regex_destroy(cs, var, cdef);
156
157 *(struct Regex **) var = r;
158
159 if (!r)
160 rc |= CSR_SUC_EMPTY;
161 }
162 else
163 {
164 if (cdef->type & DT_INITIAL_SET)
165 FREE(&cdef->initial);
166
167 cdef->type |= DT_INITIAL_SET;
168 cdef->initial = (intptr_t) mutt_str_dup(value);
169 }
170
171 return rc;
172}
regex_new
struct Regex * regex_new(const char *str, uint32_t flags, struct Buffer *err)
Create an Regex from a string.
Definition: regex.c:80
regex_free
void regex_free(struct Regex **r)
Free a Regex object.
Definition: regex.c:48
regex_destroy
static void regex_destroy(const struct ConfigSet *cs, void *var, const struct ConfigDef *cdef)
Destroy a Regex object - Implements ConfigSetType::destroy() -.
Definition: regex.c:63
Regex
Cached regular expression.
Definition: regex3.h:89
Regex::pattern
char * pattern
printable version
Definition: regex3.h:90
+ Here is the call graph for this function:

◆ slist_string_set()

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

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

Definition at line 61 of file slist.c.

63{
64 if (!cs || !cdef)
65 return CSR_ERR_CODE; /* LCOV_EXCL_LINE */
66
67 /* Store empty string list as NULL */
68 if (value && (value[0] == '\0'))
69 value = NULL;
70
71 struct Slist *list = NULL;
72
73 int rc = CSR_SUCCESS;
74
75 if (var)
76 {
77 list = slist_parse(value, cdef->type);
78
79 if (cdef->validator)
80 {
81 rc = cdef->validator(cs, cdef, (intptr_t) list, err);
82
83 if (CSR_RESULT(rc) != CSR_SUCCESS)
84 {
85 slist_free(&list);
86 return rc | CSR_INV_VALIDATOR;
87 }
88 }
89
90 slist_destroy(cs, var, cdef);
91
92 *(struct Slist **) var = list;
93
94 if (!list)
95 rc |= CSR_SUC_EMPTY;
96 }
97 else
98 {
99 if (cdef->type & DT_INITIAL_SET)
100 FREE(&cdef->initial);
101
102 cdef->type |= DT_INITIAL_SET;
103 cdef->initial = (intptr_t) mutt_str_dup(value);
104 }
105
106 return rc;
107}
slist_destroy
static void slist_destroy(const struct ConfigSet *cs, void *var, const struct ConfigDef *cdef)
Destroy an Slist object - Implements ConfigSetType::destroy() -.
Definition: slist.c:46
slist_parse
struct Slist * slist_parse(const char *str, uint32_t flags)
Parse a list of strings into a list.
Definition: slist.c:213
slist_free
void slist_free(struct Slist **list)
Free an Slist object.
Definition: slist.c:162
Slist
String list.
Definition: slist.h:47
+ Here is the call graph for this function:

◆ sort_string_set()

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

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

Definition at line 47 of file sort.c.

49{
50 intptr_t id = -1;
51 uint16_t flags = 0;
52
53 if (!value || (value[0] == '\0'))
54 {
55 buf_printf(err, _("Option %s may not be empty"), cdef->name);
56 return CSR_ERR_INVALID | CSR_INV_TYPE;
57 }
58
59 size_t plen = 0;
60
61 if (cdef->type & DT_SORT_REVERSE)
62 {
63 plen = mutt_str_startswith(value, PREFIX_REVERSE);
64 if (plen != 0)
65 {
66 flags |= SORT_REVERSE;
67 value += plen;
68 }
69 }
70
71 if (cdef->type & DT_SORT_LAST)
72 {
73 plen = mutt_str_startswith(value, PREFIX_LAST);
74 if (plen != 0)
75 {
76 flags |= SORT_LAST;
77 value += plen;
78 }
79 }
80
81 id = mutt_map_get_value(value, (struct Mapping *) cdef->data);
82
83 if (id < 0)
84 {
85 buf_printf(err, _("Invalid sort name: %s"), value);
86 return CSR_ERR_INVALID | CSR_INV_TYPE;
87 }
88
89 id |= flags;
90
91 if (var)
92 {
93 if (id == (*(short *) var))
94 return CSR_SUCCESS | CSR_SUC_NO_CHANGE;
95
96 if (cdef->validator)
97 {
98 int rc = cdef->validator(cs, cdef, (intptr_t) id, err);
99
100 if (CSR_RESULT(rc) != CSR_SUCCESS)
101 return rc | CSR_INV_VALIDATOR;
102 }
103
104 *(short *) var = id;
105 }
106 else
107 {
108 cdef->initial = id;
109 }
110
111 return CSR_SUCCESS;
112}
PREFIX_REVERSE
#define PREFIX_REVERSE
Definition: sort.c:41
PREFIX_LAST
#define PREFIX_LAST
Definition: sort.c:42
mutt_str_startswith
size_t mutt_str_startswith(const char *str, const char *prefix)
Check whether a string starts with a prefix.
Definition: string.c:228
DT_SORT_REVERSE
#define DT_SORT_REVERSE
Sort flag for -reverse prefix.
Definition: sort2.h:32
SORT_LAST
#define SORT_LAST
Sort thread by last-X, e.g. received date.
Definition: sort2.h:76
DT_SORT_LAST
#define DT_SORT_LAST
Sort flag for -last prefix.
Definition: sort2.h:31
SORT_REVERSE
#define SORT_REVERSE
Reverse the order of the sort.
Definition: sort2.h:75
Mapping
Mapping between user-readable string and a constant.
Definition: mapping.h:32
+ Here is the call graph for this function:

◆ string_string_set()

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

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

Definition at line 57 of file string.c.

59{
60 /* Store empty strings as NULL */
61 if (value && (value[0] == '\0'))
62 value = NULL;
63
64 if (!value && (cdef->type & DT_NOT_EMPTY))
65 {
66 buf_printf(err, _("Option %s may not be empty"), cdef->name);
67 return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
68 }
69
70 int rc = CSR_SUCCESS;
71
72 if (var)
73 {
74 if (mutt_str_equal(value, (*(char **) var)))
75 return CSR_SUCCESS | CSR_SUC_NO_CHANGE;
76
77 if (cdef->validator)
78 {
79 rc = cdef->validator(cs, cdef, (intptr_t) value, err);
80
81 if (CSR_RESULT(rc) != CSR_SUCCESS)
82 return rc | CSR_INV_VALIDATOR;
83 }
84
85 string_destroy(cs, var, cdef);
86
87 const char *str = mutt_str_dup(value);
88 if (!str)
89 rc |= CSR_SUC_EMPTY;
90
91 *(const char **) var = str;
92 }
93 else
94 {
95 if (cdef->type & DT_INITIAL_SET)
96 FREE(&cdef->initial);
97
98 cdef->type |= DT_INITIAL_SET;
99 cdef->initial = (intptr_t) mutt_str_dup(value);
100 }
101
102 return rc;
103}
string_destroy
static void string_destroy(const struct ConfigSet *cs, void *var, const struct ConfigDef *cdef)
Destroy a String - Implements ConfigSetType::destroy() -.
Definition: string.c:45
+ Here is the call graph for this function: