908{
909
910
911 struct PatternList *curlist = NULL;
912 bool pat_not = false;
913 bool all_addr = false;
914 bool pat_or = false;
915 bool implicit = true;
916 bool is_alias = false;
918 char *p = NULL;
919 char *buf = NULL;
921
922 if (!s || (s[0] == '\0'))
923 {
925 return NULL;
926 }
927
931
934 {
936 {
937 case '^':
939 all_addr = !all_addr;
940 break;
941 case '!':
943 pat_not = !pat_not;
944 break;
945 case '@':
947 is_alias = !is_alias;
948 break;
949 case '|':
950 if (!pat_or)
951 {
952 if (!curlist)
953 {
956 return NULL;
957 }
958
961 {
962
965 }
966
967 pat_or = true;
968 }
970 implicit = false;
974 break;
975 case '%':
976 case '=':
977 case '~':
978 {
979 if (ps->
dptr[1] ==
'\0')
980 {
982 goto cleanup;
983 }
984 short thread_op = 0;
985 if (ps->
dptr[1] ==
'(')
987 else if ((ps->
dptr[1] ==
'<') && (ps->
dptr[2] ==
'('))
989 else if ((ps->
dptr[1] ==
'>') && (ps->
dptr[2] ==
'('))
991 if (thread_op != 0)
992 {
998 {
1000 goto cleanup;
1001 }
1003 leaf->
op = thread_op;
1010
1014 {
1016 goto cleanup;
1017 }
1020 break;
1021 }
1022 if (implicit && pat_or)
1023 {
1024
1027 pat_or = false;
1028 }
1029
1031 if (!entry)
1032 {
1034 goto cleanup;
1035 }
1036 if (entry->
flags && ((flags & entry->
flags) == 0))
1037 {
1039 goto cleanup;
1040 }
1041
1049 leaf->
op = entry->
op;
1053
1058 {
1059 if (ps->
dptr[0] ==
'\0')
1060 {
1062 goto cleanup;
1063 }
1065 {
1068 goto cleanup;
1069 break;
1071 if (!
eat_date(leaf, flags, ps, err))
1072 goto cleanup;
1073 break;
1076 goto cleanup;
1077 break;
1080 goto cleanup;
1081 break;
1083 if (!
eat_query(leaf, flags, ps, err, m))
1084 goto cleanup;
1085 break;
1086 default:
1087 break;
1088 }
1089 }
1090 implicit = true;
1091 break;
1092 }
1093
1094 case '(':
1095 {
1098 {
1100 goto cleanup;
1101 }
1102
1106 if (!sub)
1107 goto cleanup;
1109 if (curlist)
1110 {
1113 }
1114 else
1115 {
1116 curlist = sub;
1117 }
1125 break;
1126 }
1127
1128 default:
1130 goto cleanup;
1131 }
1133 }
1135
1136 if (!curlist)
1137 {
1139 return NULL;
1140 }
1141
1143 {
1146 }
1147
1148 return curlist;
1149
1150cleanup:
1153 return NULL;
1154}
void buf_seek(struct Buffer *buf, size_t offset)
Set current read/write position to offset from beginning.
size_t buf_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
static struct Pattern * attach_new_leaf(struct PatternList **curlist)
Attach a new Pattern to a List.
static char * find_matching_paren(char *s)
Find the matching parenthesis.
struct PatternList * mutt_pattern_comp(struct MailboxView *mv, struct Menu *menu, const char *s, PatternCompFlags flags, struct Buffer *err)
Create a Pattern.
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 -.
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 -.
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 -.
static bool eat_regex(struct Pattern *pat, PatternCompFlags flags, struct Buffer *s, struct Buffer *err)
Parse a regex - Implements eat_arg_t -.
char * mutt_strn_dup(const char *begin, size_t len)
Duplicate a sub-string.
const struct PatternFlags * lookup_tag(char tag)
Lookup a pattern modifier.
#define MUTT_PC_SEND_MODE_SEARCH
Allow send-mode body searching.
@ MUTT_PAT_OR
Either pattern can match.
@ MUTT_PAT_CHILDREN
Pattern matches a child email.
@ MUTT_PAT_PARENT
Pattern matches parent.
@ MUTT_PAT_AND
Both patterns must match.
@ MUTT_PAT_THREAD
Pattern matches email thread.
@ EAT_RANGE
Process a number (range)
@ EAT_MESSAGE_RANGE
Process a message number (range)
@ EAT_DATE
Process a date (range)
@ EAT_QUERY
Process a query string.
@ EAT_REGEX
Process a regex.
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
String manipulation buffer.
char * dptr
Current read/write position.
struct Mailbox * mailbox
Current Mailbox.
Mapping between user character and internal constant.
enum PatternEat eat_arg
Type of function needed to parse flag, e.g. EAT_DATE.
PatternCompFlags flags
Pattern flags, e.g. MUTT_PC_FULL_MSG.
int op
Operation to perform, e.g. MUTT_PAT_SCORE.
bool all_addr
All Addresses in the list must match.
bool is_alias
Is there an alias for this Address?
short op
Operation, e.g. MUTT_PAT_SCORE.
bool sendmode
Evaluate searches in send-mode.
bool pat_not
Pattern should be inverted (not)