NeoMutt  2025-12-11-58-g09398d
Teaching an old dog new tricks
 		DOXYGEN
Loading...
Searching...
No Matches
Functions
Parse a pattern API

Prototype for a function to parse a pattern. More...

Functions

static bool eat_regex (struct Pattern *pat, PatternCompFlags flags, struct Buffer *s, struct Buffer *err)
 Parse a regex - Implements eat_arg_t -.
 
static bool eat_query (struct Pattern *pat, PatternCompFlags flags, struct Buffer *s, struct Buffer *err, struct Mailbox *m)
 Parse a query for an external search program - Implements eat_arg_t -.
 
static bool eat_range (struct Pattern *pat, PatternCompFlags flags, struct Buffer *s, struct Buffer *err)
 Parse a number range - Implements eat_arg_t -.
 
static bool eat_date (struct Pattern *pat, PatternCompFlags flags, struct Buffer *s, struct Buffer *err)
 Parse a date pattern - Implements eat_arg_t -.
 
bool eat_message_range (struct Pattern *pat, PatternCompFlags flags, struct Buffer *s, struct Buffer *err, struct MailboxView *mv)
 Parse a range of message numbers - Implements eat_arg_t -.
 

Detailed Description

Prototype for a function to parse a pattern.

Parameters
patPattern to store the results in
flagsFlags, e.g. MUTT_PC_PATTERN_DYNAMIC
sString to parse
errBuffer for error messages
Return values
trueThe pattern was read successfully

Function Documentation

◆ eat_regex()

static bool eat_regex ( struct Pattern * pat,
PatternCompFlags flags,
struct Buffer * s,
struct Buffer * err )
static

Parse a regex - Implements eat_arg_t -.

Definition at line 64 of file compile.c.

66{
67 struct Buffer *token = buf_pool_get();
68 bool rc = false;
69 char *pexpr = s->dptr;
70 if ((parse_extract_token(token, s, TOKEN_PATTERN | TOKEN_COMMENT) != 0) ||
71 !token->data)
72 {
73 buf_printf(err, _("Error in expression: %s"), pexpr);
74 goto out;
75 }
76 if (buf_is_empty(token))
77 {
78 buf_addstr(err, _("Empty expression"));
79 goto out;
80 }
81
82 if (pat->string_match)
83 {
84 pat->p.str = buf_strdup(token);
85 pat->ign_case = mutt_mb_is_lower(token->data);
86 }
87 else if (pat->group_match)
88 {
89 pat->p.group = groups_get_group(NeoMutt->groups, token->data);
90 }
91 else
92 {
93 pat->p.regex = MUTT_MEM_CALLOC(1, regex_t);
94#ifdef USE_DEBUG_GRAPHVIZ
95 pat->raw_pattern = buf_strdup(token);
96#endif
97 uint16_t case_flags = mutt_mb_is_lower(token->data) ? REG_ICASE : 0;
98 int rc2 = REG_COMP(pat->p.regex, token->data, REG_NEWLINE | REG_NOSUB | case_flags);
99 if (rc2 != 0)
100 {
101 char errmsg[256] = { 0 };
102 regerror(rc2, pat->p.regex, errmsg, sizeof(errmsg));
103 buf_printf(err, "'%s': %s", token->data, errmsg);
104 FREE(&pat->p.regex);
105 goto out;
106 }
107 }
108
109 rc = true;
110
111out:
112 buf_pool_release(&token);
113 return rc;
114}
buf_printf
int buf_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition buffer.c:161
buf_is_empty
bool buf_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition buffer.c:291
buf_addstr
size_t buf_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
Definition buffer.c:226
buf_strdup
char * buf_strdup(const struct Buffer *buf)
Copy a Buffer's string.
Definition buffer.c:571
parse_extract_token
int parse_extract_token(struct Buffer *dest, struct Buffer *line, TokenFlags flags)
Extract one token from a string.
Definition extract.c:48
TOKEN_COMMENT
#define TOKEN_COMMENT
Don't reap comments.
Definition extract.h:50
TOKEN_PATTERN
#define TOKEN_PATTERN
~%=!| are terms (for patterns)
Definition extract.h:49
groups_get_group
struct Group * groups_get_group(struct HashTable *groups, const char *name)
Get a Group by its name.
Definition group.c:291
mutt_mb_is_lower
bool mutt_mb_is_lower(const char *s)
Does a multi-byte string contain only lowercase characters?
Definition mbyte.c:354
FREE
#define FREE(x)
Definition memory.h:62
MUTT_MEM_CALLOC
#define MUTT_MEM_CALLOC(n, type)
Definition memory.h:47
_
#define _(a)
Definition message.h:28
buf_pool_get
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
Definition pool.c:82
buf_pool_release
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition pool.c:96
REG_COMP
#define REG_COMP(preg, regex, cflags)
Compile a regular expression.
Definition regex3.h:50
Buffer
String manipulation buffer.
Definition buffer.h:36
Buffer::dptr
char * dptr
Current read/write position.
Definition buffer.h:38
Buffer::data
char * data
Pointer to data.
Definition buffer.h:37
NeoMutt
Container for Accounts, Notifications.
Definition neomutt.h:43
NeoMutt::groups
struct HashTable * groups
Hash Table: "group-name" -> Group.
Definition neomutt.h:52
Pattern::group_match
bool group_match
Check a group of Addresses.
Definition lib.h:82
Pattern::p
union Pattern::@006112053024257132210207314205210350156165326341 p
Pattern::group
struct Group * group
Address group if group_match is set.
Definition lib.h:93
Pattern::string_match
bool string_match
Check a string for a match.
Definition lib.h:81
Pattern::regex
regex_t * regex
Compiled regex, for non-pattern matching.
Definition lib.h:92
Pattern::str
char * str
String, if string_match is set.
Definition lib.h:94
Pattern::ign_case
bool ign_case
Ignore case for local string_match searches.
Definition lib.h:83
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ eat_query()

static bool eat_query ( struct Pattern * pat,
PatternCompFlags flags,
struct Buffer * s,
struct Buffer * err,
struct Mailbox * m )
static

Parse a query for an external search program - Implements eat_arg_t -.

Parameters
patPattern to store the results in
flagsFlags, e.g. MUTT_PC_PATTERN_DYNAMIC
sString to parse
errBuffer for error messages
mMailbox
Return values
trueThe pattern was read successfully

Definition at line 140 of file compile.c.

142{
143 struct Buffer *cmd = buf_pool_get();
144 struct Buffer *tok = buf_pool_get();
145 bool rc = false;
146
147 FILE *fp = NULL;
148
149 const char *const c_external_search_command = cs_subset_string(NeoMutt->sub, "external_search_command");
150 if (!c_external_search_command)
151 {
152 buf_addstr(err, _("No search command defined"));
153 goto out;
154 }
155
156 char *pexpr = s->dptr;
157 if ((parse_extract_token(tok, s, TOKEN_PATTERN | TOKEN_COMMENT) != 0) || !tok->data)
158 {
159 buf_printf(err, _("Error in expression: %s"), pexpr);
160 goto out;
161 }
162 if (*tok->data == '\0')
163 {
164 buf_addstr(err, _("Empty expression"));
165 goto out;
166 }
167
168 buf_addstr(cmd, c_external_search_command);
169 buf_addch(cmd, ' ');
170
171 if (m)
172 {
173 char *escaped_folder = mutt_path_escape(mailbox_path(m));
174 mutt_debug(LL_DEBUG2, "escaped folder path: %s\n", escaped_folder);
175 buf_addch(cmd, '\'');
176 buf_addstr(cmd, escaped_folder);
177 buf_addch(cmd, '\'');
178 }
179 else
180 {
181 buf_addch(cmd, '/');
182 }
183 buf_addch(cmd, ' ');
184 buf_addstr(cmd, tok->data);
185
186 mutt_message(_("Running search command: %s ..."), cmd->data);
187 pat->is_multi = true;
188 mutt_list_clear(&pat->p.multi_cases);
189 pid_t pid = filter_create(cmd->data, NULL, &fp, NULL, NeoMutt->env);
190 if (pid < 0)
191 {
192 buf_printf(err, "unable to fork command: %s\n", cmd->data);
193 goto out;
194 }
195
196 mutt_file_map_lines(add_query_msgid, &pat->p.multi_cases, fp, MUTT_RL_NO_FLAGS);
197 mutt_file_fclose(&fp);
198 filter_wait(pid);
199
200 rc = true;
201
202out:
203 buf_pool_release(&cmd);
204 buf_pool_release(&tok);
205 return rc;
206}
buf_addch
size_t buf_addch(struct Buffer *buf, char c)
Add a single character to a Buffer.
Definition buffer.c:241
cs_subset_string
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition helpers.c:291
mailbox_path
static const char * mailbox_path(const struct Mailbox *m)
Get the Mailbox's path string.
Definition mailbox.h:214
mutt_file_map_lines
bool mutt_file_map_lines(mutt_file_map_t func, void *user_data, FILE *fp, ReadLineFlags flags)
Process lines of text read from a file pointer.
Definition file.c:787
mutt_file_fclose
#define mutt_file_fclose(FP)
Definition file.h:139
MUTT_RL_NO_FLAGS
#define MUTT_RL_NO_FLAGS
No flags are set.
Definition file.h:40
mutt_message
#define mutt_message(...)
Definition logging2.h:92
mutt_debug
#define mutt_debug(LEVEL,...)
Definition logging2.h:90
add_query_msgid
static bool add_query_msgid(char *line, int line_num, void *user_data)
Parse a Message-Id and add it to a list - Implements mutt_file_map_t -.
Definition compile.c:120
mutt_list_clear
void mutt_list_clear(struct ListHead *h)
Free a list, but NOT its strings.
Definition list.c:166
LL_DEBUG2
@ LL_DEBUG2
Log at debug level 2.
Definition logging2.h:45
filter_wait
int filter_wait(pid_t pid)
Wait for the exit of a process and return its status.
Definition filter.c:220
filter_create
pid_t filter_create(const char *cmd, FILE **fp_in, FILE **fp_out, FILE **fp_err, char **envlist)
Set up filter program.
Definition filter.c:209
mutt_path_escape
char * mutt_path_escape(const char *src)
Escapes single quotes in a path for a command string.
Definition path.c:433
NeoMutt::env
char ** env
Private copy of the environment variables.
Definition neomutt.h:56
NeoMutt::sub
struct ConfigSubset * sub
Inherited config items.
Definition neomutt.h:47
Pattern::multi_cases
struct ListHead multi_cases
Multiple strings for ~I pattern.
Definition lib.h:95
Pattern::is_multi
bool is_multi
Multiple case (only for ~I pattern now)
Definition lib.h:87
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ eat_range()

static bool eat_range ( struct Pattern * pat,
PatternCompFlags flags,
struct Buffer * s,
struct Buffer * err )
static

Parse a number range - Implements eat_arg_t -.

Definition at line 620 of file compile.c.

622{
623 char *tmp = NULL;
624 bool do_exclusive = false;
625 bool skip_quote = false;
626
627 /* If simple_search is set to "~m %s", the range will have double quotes
628 * around it... */
629 if (*s->dptr == '"')
630 {
631 s->dptr++;
632 skip_quote = true;
633 }
634 if (*s->dptr == '<')
635 do_exclusive = true;
636 if ((*s->dptr != '-') && (*s->dptr != '<'))
637 {
638 /* range minimum */
639 if (*s->dptr == '>')
640 {
641 pat->max = MUTT_MAXRANGE;
642 pat->min = strtol(s->dptr + 1, &tmp, 0) + 1; /* exclusive range */
643 }
644 else
645 {
646 pat->min = strtol(s->dptr, &tmp, 0);
647 }
648 if (mutt_toupper(*tmp) == 'K') /* is there a prefix? */
649 {
650 pat->min *= 1024;
651 tmp++;
652 }
653 else if (mutt_toupper(*tmp) == 'M')
654 {
655 pat->min *= 1048576;
656 tmp++;
657 }
658 if (*s->dptr == '>')
659 {
660 s->dptr = tmp;
661 return true;
662 }
663 if (*tmp != '-')
664 {
665 /* exact value */
666 pat->max = pat->min;
667 s->dptr = tmp;
668 return true;
669 }
670 tmp++;
671 }
672 else
673 {
674 s->dptr++;
675 tmp = s->dptr;
676 }
677
678 if (mutt_isdigit(*tmp))
679 {
680 /* range maximum */
681 pat->max = strtol(tmp, &tmp, 0);
682 if (mutt_toupper(*tmp) == 'K')
683 {
684 pat->max *= 1024;
685 tmp++;
686 }
687 else if (mutt_toupper(*tmp) == 'M')
688 {
689 pat->max *= 1048576;
690 tmp++;
691 }
692 if (do_exclusive)
693 (pat->max)--;
694 }
695 else
696 {
697 pat->max = MUTT_MAXRANGE;
698 }
699
700 if (skip_quote && (*tmp == '"'))
701 tmp++;
702
703 SKIPWS(tmp);
704 s->dptr = tmp;
705 return true;
706}
mutt_toupper
int mutt_toupper(int arg)
Wrapper for toupper(3)
Definition ctype.c:139
mutt_isdigit
bool mutt_isdigit(int arg)
Wrapper for isdigit(3)
Definition ctype.c:65
MUTT_MAXRANGE
#define MUTT_MAXRANGE
Definition private.h:141
SKIPWS
#define SKIPWS(ch)
Definition string2.h:51
Pattern::min
long min
Minimum for range checks.
Definition lib.h:88
Pattern::max
long max
Maximum for range checks.
Definition lib.h:89
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ eat_date()

static bool eat_date ( struct Pattern * pat,
PatternCompFlags flags,
struct Buffer * s,
struct Buffer * err )
static

Parse a date pattern - Implements eat_arg_t -.

Definition at line 711 of file compile.c.

713{
714 struct Buffer *tmp = buf_pool_get();
715 bool rc = false;
716
717 char *pexpr = s->dptr;
718 if (parse_extract_token(tmp, s, TOKEN_COMMENT | TOKEN_PATTERN) != 0)
719 {
720 buf_printf(err, _("Error in expression: %s"), pexpr);
721 goto out;
722 }
723
724 if (buf_is_empty(tmp))
725 {
726 buf_addstr(err, _("Empty expression"));
727 goto out;
728 }
729
730 if (flags & MUTT_PC_PATTERN_DYNAMIC)
731 {
732 pat->dynamic = true;
733 pat->p.str = buf_strdup(tmp);
734 }
735
736 rc = eval_date_minmax(pat, tmp->data, err);
737
738out:
739 buf_pool_release(&tmp);
740 return rc;
741}
eval_date_minmax
bool eval_date_minmax(struct Pattern *pat, const char *s, struct Buffer *err)
Evaluate a date-range pattern against 'now'.
Definition compile.c:492
MUTT_PC_PATTERN_DYNAMIC
#define MUTT_PC_PATTERN_DYNAMIC
Enable runtime date range evaluation.
Definition lib.h:70
Pattern::dynamic
bool dynamic
Evaluate date ranges at run time.
Definition lib.h:85
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ eat_message_range()

bool eat_message_range ( struct Pattern * pat,
PatternCompFlags flags,
struct Buffer * s,
struct Buffer * err,
struct MailboxView * mv )

Parse a range of message numbers - Implements eat_arg_t -.

Parameters
patPattern to store the results in
flagsFlags, e.g. MUTT_PC_PATTERN_DYNAMIC
sString to parse
errBuffer for error messages
mvMailbox view
Return values
trueThe pattern was read successfully

Definition at line 280 of file message.c.

282{
283 if (!mv || !mv->mailbox || !mv->menu)
284 {
285 // We need these for pretty much anything
286 buf_strcpy(err, _("No mailbox is open"));
287 return false;
288 }
289
290 bool skip_quote = false;
291
292 /* If simple_search is set to "~m %s", the range will have double quotes
293 * around it... */
294 if (*s->dptr == '"')
295 {
296 s->dptr++;
297 skip_quote = true;
298 }
299
300 for (int i_kind = 0; i_kind != RANGE_K_INVALID; i_kind++)
301 {
302 switch (eat_range_by_regex(pat, s, i_kind, err, mv))
303 {
304 case RANGE_E_MVIEW:
305 /* This means it matched syntactically but lacked context.
306 * No point in continuing. */
307 break;
308 case RANGE_E_SYNTAX:
309 /* Try another syntax, then */
310 continue;
311 case RANGE_E_OK:
312 if (skip_quote && (*s->dptr == '"'))
313 s->dptr++;
314 SKIPWS(s->dptr);
315 return true;
316 }
317 }
318 return false;
319}
buf_strcpy
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition buffer.c:395
eat_range_by_regex
static int eat_range_by_regex(struct Pattern *pat, struct Buffer *s, int kind, struct Buffer *err, struct MailboxView *mv)
Parse a range given as a regex.
Definition message.c:215
RANGE_E_MVIEW
@ RANGE_E_MVIEW
Range requires MailboxView, but none available.
Definition message.c:50
RANGE_E_OK
@ RANGE_E_OK
Range is valid.
Definition message.c:48
RANGE_E_SYNTAX
@ RANGE_E_SYNTAX
Range contains syntax error.
Definition message.c:49
RANGE_K_INVALID
@ RANGE_K_INVALID
Range is invalid.
Definition private.h:96
MailboxView::menu
struct Menu * menu
Needed for pattern compilation.
Definition mview.h:47
MailboxView::mailbox
struct Mailbox * mailbox
Current Mailbox.
Definition mview.h:51
+ Here is the call graph for this function:
+ Here is the caller graph for this function: