NeoMutt  2025-12-11-980-ge38c27
Teaching an old dog new tricks
 		DOXYGEN
Loading...
Searching...
No Matches
Functions
extract.c File Reference

Text parser. More...

#include "config.h"
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "extract.h"
+ Include dependency graph for extract.c:

Go to the source code of this file.

Functions

int parse_extract_token (struct Buffer *dest, struct Buffer *line, TokenFlags flags)
 Extract one token from a string.
 

Detailed Description

Text parser.

Authors
  • Naveen Nathan
  • Richard Russon
  • Pietro Cerutti
  • Thomas Klausner
Copyright
This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file extract.c.

Function Documentation

◆ parse_extract_token()

int parse_extract_token ( struct Buffer * dest,
struct Buffer * line,
TokenFlags flags )

Extract one token from a string.

Parameters
destBuffer for the result
lineBuffer containing tokens
flagsFlags, see TokenFlags
Return values
0Success
-1Error

Definition at line 49 of file extract.c.

50{
51 if (!dest || !line)
52 return -1;
53
54 char ch;
55 char qc = '\0'; /* quote char */
56 char *pc = NULL;
57
58 buf_reset(dest);
59
60 SKIPWS(line->dptr);
61 while ((ch = *line->dptr))
62 {
63 if (qc == '\0')
64 {
65 if (mutt_isspace(ch) && !(flags & TOKEN_SPACE))
66 break;
67 if ((ch == '#') && !(flags & TOKEN_COMMENT))
68 break;
69 if ((ch == '+') && (flags & TOKEN_PLUS))
70 break;
71 if ((ch == '-') && (flags & TOKEN_MINUS))
72 break;
73 if ((ch == '=') && (flags & TOKEN_EQUAL))
74 break;
75 if ((ch == '?') && (flags & TOKEN_QUESTION))
76 break;
77 if ((ch == ';') && !(flags & TOKEN_SEMICOLON))
78 break;
79 if ((flags & TOKEN_PATTERN) && strchr("~%=!|", ch))
80 break;
81 }
82
83 line->dptr++;
84
85 if (ch == qc)
86 {
87 qc = 0; /* end of quote */
88 }
89 else if (!qc && ((ch == '\'') || (ch == '"')) && !(flags & TOKEN_QUOTE))
90 {
91 qc = ch;
92 }
93 else if ((ch == '\\') && (qc != '\''))
94 {
95 if (line->dptr[0] == '\0')
96 return -1; /* premature end of token */
97 switch (ch = *line->dptr++)
98 {
99 case 'c':
100 case 'C':
101 if (line->dptr[0] == '\0')
102 return -1; /* premature end of token */
103 buf_addch(dest, (mutt_toupper(line->dptr[0]) - '@') & 0x7f);
104 line->dptr++;
105 break;
106 case 'e':
107 buf_addch(dest, '\033'); // Escape
108 break;
109 case 'f':
110 buf_addch(dest, '\f');
111 break;
112 case 'n':
113 buf_addch(dest, '\n');
114 break;
115 case 'r':
116 buf_addch(dest, '\r');
117 break;
118 case 't':
119 buf_addch(dest, '\t');
120 break;
121 default:
122 if (mutt_isdigit(ch) && mutt_isdigit(line->dptr[0]) &&
123 mutt_isdigit(line->dptr[1]))
124 {
125 buf_addch(dest, (ch << 6) + (line->dptr[0] << 3) + line->dptr[1] - 3504);
126 line->dptr += 2;
127 }
128 else
129 {
130 buf_addch(dest, ch);
131 }
132 }
133 }
134 else if ((ch == '^') && (flags & TOKEN_CONDENSE))
135 {
136 if (line->dptr[0] == '\0')
137 return -1; /* premature end of token */
138 ch = *line->dptr++;
139 if (ch == '^')
140 {
141 buf_addch(dest, ch);
142 }
143 else if (ch == '[')
144 {
145 buf_addch(dest, '\033'); // Escape
146 }
147 else if (mutt_isalpha(ch))
148 {
149 buf_addch(dest, mutt_toupper(ch) - '@');
150 }
151 else
152 {
153 buf_addch(dest, '^');
154 buf_addch(dest, ch);
155 }
156 }
157 else if ((ch == '`') && (!qc || (qc == '"')))
158 {
159 FILE *fp = NULL;
160 pid_t pid;
161
162 pc = line->dptr;
163 do
164 {
165 pc = strpbrk(pc, "\\`");
166 if (pc)
167 {
168 /* skip any quoted chars */
169 if (*pc == '\\')
170 {
171 if (*(pc + 1))
172 pc += 2;
173 else
174 pc = NULL;
175 }
176 }
177 } while (pc && (pc[0] != '`'));
178 if (!pc)
179 {
180 mutt_debug(LL_DEBUG1, "mismatched backticks\n");
181 return -1;
182 }
183 struct Buffer *cmd = buf_pool_get();
184 *pc = '\0';
185 /* Recursively extract tokens to interpolate NeoMutt variables.
186 * TOKEN_NOSHELL leaves unknown/env variables for the shell to expand. */
187 if (parse_extract_token(cmd, line,
188 TOKEN_QUOTE | TOKEN_SPACE | TOKEN_COMMENT |
189 TOKEN_SEMICOLON | TOKEN_NOSHELL) != 0)
190 {
191 *pc = '`';
192 buf_pool_release(&cmd);
193 return -1;
194 }
195 *pc = '`';
196 pid = filter_create(buf_string(cmd), NULL, &fp, NULL, NeoMutt->env);
197 if (pid < 0)
198 {
199 mutt_debug(LL_DEBUG1, "unable to fork command: %s\n", buf_string(cmd));
200 buf_pool_release(&cmd);
201 return -1;
202 }
203
204 line->dptr = pc + 1;
205
206 /* read line */
207 char *expn = NULL;
208 size_t expn_len = 0;
209 expn = mutt_file_read_line(expn, &expn_len, fp, NULL, MUTT_RL_NONE);
210 mutt_file_fclose(&fp);
211 int rc = filter_wait(pid);
212 if (rc != 0)
213 {
214 mutt_debug(LL_DEBUG1, "backticks exited code %d for command: %s\n", rc,
215 buf_string(cmd));
216 }
217 buf_pool_release(&cmd);
218
219 /* if we got output, make a new string consisting of the shell output
220 * plus whatever else was left on the original line */
221 /* BUT: If this is inside a quoted string, directly add output to
222 * the token */
223 if (expn)
224 {
225 if (qc)
226 {
227 buf_addstr(dest, expn);
228 }
229 else
230 {
231 struct Buffer *copy = buf_pool_get();
232 buf_strcpy(copy, expn);
233 buf_addstr(copy, line->dptr);
234 buf_copy(line, copy);
235 buf_seek(line, 0);
236 buf_pool_release(&copy);
237 }
238 FREE(&expn);
239 }
240 }
241 else if ((ch == '$') && (!qc || (qc == '"')) &&
242 ((line->dptr[0] == '{') || mutt_isalpha(line->dptr[0])))
243 {
244 const char *env = NULL;
245 char *var = NULL;
246
247 if (line->dptr[0] == '{')
248 {
249 pc = strchr(line->dptr, '}');
250 if (pc)
251 {
252 var = mutt_strn_dup(line->dptr + 1, pc - (line->dptr + 1));
253 line->dptr = pc + 1;
254
255 if ((flags & TOKEN_NOSHELL))
256 {
257 buf_addch(dest, ch);
258 buf_addch(dest, '{');
259 buf_addstr(dest, var);
260 buf_addch(dest, '}');
261 FREE(&var);
262 }
263 }
264 }
265 else
266 {
267 for (pc = line->dptr; mutt_isalnum(*pc) || (pc[0] == '_'); pc++)
268 ; // do nothing
269
270 var = mutt_strn_dup(line->dptr, pc - line->dptr);
271 line->dptr = pc;
272 }
273 if (var)
274 {
275 struct Buffer *result = buf_pool_get();
276 int rc = cs_subset_str_string_get(NeoMutt->sub, var, result);
277
278 if (CSR_RESULT(rc) == CSR_SUCCESS)
279 {
280 buf_addstr(dest, buf_string(result));
281 }
282 else if (!(flags & TOKEN_NOSHELL) && (env = mutt_str_getenv(var)))
283 {
284 buf_addstr(dest, env);
285 }
286 else
287 {
288 buf_addch(dest, ch);
289 buf_addstr(dest, var);
290 }
291 FREE(&var);
292 buf_pool_release(&result);
293 }
294 }
295 else
296 {
297 buf_addch(dest, ch);
298 }
299 }
300
301 SKIPWS(line->dptr);
302 return 0;
303}
buf_seek
void buf_seek(struct Buffer *buf, size_t offset)
Set current read/write position to offset from beginning.
Definition buffer.c:628
buf_reset
void buf_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition buffer.c:89
buf_addch
size_t buf_addch(struct Buffer *buf, char c)
Add a single character to a Buffer.
Definition buffer.c:248
buf_addstr
size_t buf_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
Definition buffer.c:233
buf_strcpy
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition buffer.c:401
buf_copy
size_t buf_copy(struct Buffer *dst, const struct Buffer *src)
Copy a Buffer's contents to another Buffer.
Definition buffer.c:607
buf_string
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition buffer.h:96
CSR_RESULT
#define CSR_RESULT(x)
Extract the result code from CSR_* flags.
Definition set.h:53
CSR_SUCCESS
#define CSR_SUCCESS
Action completed successfully.
Definition set.h:33
mutt_isspace
bool mutt_isspace(int arg)
Wrapper for isspace(3)
Definition ctype.c:96
mutt_isalpha
bool mutt_isalpha(int arg)
Wrapper for isalpha(3)
Definition ctype.c:53
mutt_toupper
int mutt_toupper(int arg)
Wrapper for toupper(3)
Definition ctype.c:140
mutt_isalnum
bool mutt_isalnum(int arg)
Wrapper for isalnum(3)
Definition ctype.c:40
mutt_isdigit
bool mutt_isdigit(int arg)
Wrapper for isdigit(3)
Definition ctype.c:66
parse_extract_token
int parse_extract_token(struct Buffer *dest, struct Buffer *line, TokenFlags flags)
Extract one token from a string.
Definition extract.c:49
TOKEN_COMMENT
@ TOKEN_COMMENT
Don't reap comments.
Definition extract.h:56
TOKEN_MINUS
@ TOKEN_MINUS
Treat '-' as a special.
Definition extract.h:61
TOKEN_SPACE
@ TOKEN_SPACE
Don't treat whitespace as a term.
Definition extract.h:53
TOKEN_EQUAL
@ TOKEN_EQUAL
Treat '=' as a special.
Definition extract.h:51
TOKEN_QUOTE
@ TOKEN_QUOTE
Don't interpret quotes.
Definition extract.h:54
TOKEN_PATTERN
@ TOKEN_PATTERN
~%=!| are terms (for patterns)
Definition extract.h:55
TOKEN_CONDENSE
@ TOKEN_CONDENSE
^(char) to control chars (macros)
Definition extract.h:52
TOKEN_PLUS
@ TOKEN_PLUS
Treat '+' as a special.
Definition extract.h:60
TOKEN_NOSHELL
@ TOKEN_NOSHELL
Don't expand environment variables.
Definition extract.h:58
TOKEN_SEMICOLON
@ TOKEN_SEMICOLON
Don't treat ; as special.
Definition extract.h:57
TOKEN_QUESTION
@ TOKEN_QUESTION
Treat '?' as a special.
Definition extract.h:59
mutt_file_read_line
char * mutt_file_read_line(char *line, size_t *size, FILE *fp, int *line_num, ReadLineFlags flags)
Read a line from a file.
Definition file.c:678
mutt_file_fclose
#define mutt_file_fclose(FP)
Definition file.h:144
MUTT_RL_NONE
@ MUTT_RL_NONE
No flags are set.
Definition file.h:43
mutt_debug
#define mutt_debug(LEVEL,...)
Definition logging2.h:91
LL_DEBUG1
@ LL_DEBUG1
Log at debug level 1.
Definition logging2.h:45
FREE
#define FREE(x)
Free memory and set the pointer to NULL.
Definition memory.h:68
filter_wait
int filter_wait(pid_t pid)
Wait for the exit of a process and return its status.
Definition filter.c:231
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:220
mutt_strn_dup
char * mutt_strn_dup(const char *begin, size_t len)
Duplicate a sub-string.
Definition string.c:384
mutt_str_getenv
const char * mutt_str_getenv(const char *name)
Get an environment variable.
Definition string.c:732
buf_pool_get
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
Definition pool.c:91
buf_pool_release
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition pool.c:111
SKIPWS
#define SKIPWS(ch)
Definition string2.h:52
Buffer
String manipulation buffer.
Definition buffer.h:36
Buffer::dptr
char * dptr
Current read/write position.
Definition buffer.h:38
NeoMutt
Container for Accounts, Notifications.
Definition neomutt.h:41
NeoMutt::env
char ** env
Private copy of the environment variables.
Definition neomutt.h:57
NeoMutt::sub
struct ConfigSubset * sub
Inherited config items.
Definition neomutt.h:49
cs_subset_str_string_get
int cs_subset_str_string_get(const struct ConfigSubset *sub, const char *name, struct Buffer *result)
Get a config item as a string.
Definition subset.c:354
+ Here is the call graph for this function: