1 /* quotearg.h - quote arguments for output
2
3 Copyright (C) 1998-2002, 2004, 2006, 2008-2021 Free Software Foundation,
4 Inc.
5
6 This program is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <https://www.gnu.org/licenses/>. */
18
19 /* Written by Paul Eggert <eggert@twinsun.com> */
20
21 #ifndef QUOTEARG_H_
22 # define QUOTEARG_H_ 1
23
24 # include <stdlib.h>
25
26 /* Basic quoting styles. For each style, an example is given on the
27 input strings "simple", "\0 \t\n'\"\033?""?/\\", and "a:b", using
28 quotearg_buffer, quotearg_mem, and quotearg_colon_mem with that
29 style and the default flags and quoted characters. Note that the
30 examples are shown here as valid C strings rather than what
31 displays on a terminal (with "??/" as a trigraph for "\\"). */
32 enum quoting_style
33 {
34 /* Output names as-is (ls --quoting-style=literal). Can result in
35 embedded null bytes if QA_ELIDE_NULL_BYTES is not in
36 effect.
37
38 quotearg_buffer:
39 "simple", "\0 \t\n'\"\033??/\\", "a:b"
40 quotearg:
41 "simple", " \t\n'\"\033??/\\", "a:b"
42 quotearg_colon:
43 "simple", " \t\n'\"\033??/\\", "a:b"
44 */
45 literal_quoting_style,
46
47 /* Quote names for the shell if they contain shell metacharacters
48 or would cause ambiguous output (ls --quoting-style=shell).
49 Can result in embedded null bytes if QA_ELIDE_NULL_BYTES is not
50 in effect.
51
52 quotearg_buffer:
53 "simple", "'\0 \t\n'\\''\"\033??/\\'", "a:b"
54 quotearg:
55 "simple", "' \t\n'\\''\"\033??/\\'", "a:b"
56 quotearg_colon:
57 "simple", "' \t\n'\\''\"\033??/\\'", "'a:b'"
58 */
59 shell_quoting_style,
60
61 /* Quote names for the shell, even if they would normally not
62 require quoting (ls --quoting-style=shell-always). Can result
63 in embedded null bytes if QA_ELIDE_NULL_BYTES is not in effect.
64 Behaves like shell_quoting_style if QA_ELIDE_OUTER_QUOTES is in
65 effect.
66
67 quotearg_buffer:
68 "'simple'", "'\0 \t\n'\\''\"\033??/\\'", "'a:b'"
69 quotearg:
70 "'simple'", "' \t\n'\\''\"\033??/\\'", "'a:b'"
71 quotearg_colon:
72 "'simple'", "' \t\n'\\''\"\033??/\\'", "'a:b'"
73 */
74 shell_always_quoting_style,
75
76 /* Quote names for the shell if they contain shell metacharacters
77 or other problematic characters (ls --quoting-style=shell-escape).
78 Non printable characters are quoted using the $'...' syntax,
79 which originated in ksh93 and is widely supported by most shells,
80 and proposed for inclusion in POSIX.
81
82 quotearg_buffer:
83 "simple", "''$'\\0'' '$'\\t\\n'\\''\"'$'\\033''??/\\'", "a:b"
84 quotearg:
85 "simple", "''$'\\0'' '$'\\t\\n'\\''\"'$'\\033''??/\\'", "a:b"
86 quotearg_colon:
87 "simple", "''$'\\0'' '$'\\t\\n'\\''\"'$'\\033''??/\\'", "'a:b'"
88 */
89 shell_escape_quoting_style,
90
91 /* Quote names for the shell even if they would normally not
92 require quoting (ls --quoting-style=shell-escape).
93 Non printable characters are quoted using the $'...' syntax,
94 which originated in ksh93 and is widely supported by most shells,
95 and proposed for inclusion in POSIX. Behaves like
96 shell_escape_quoting_style if QA_ELIDE_OUTER_QUOTES is in effect.
97
98 quotearg_buffer:
99 "simple", "''$'\\0'' '$'\\t\\n'\\''\"'$'\\033''??/\'", "a:b"
100 quotearg:
101 "simple", "''$'\\0'' '$'\\t\\n'\\''\"'$'\\033''??/\'", "a:b"
102 quotearg_colon:
103 "simple", "''$'\\0'' '$'\\t\\n'\\''\"'$'\\033''??/\'", "'a:b'"
104 */
105 shell_escape_always_quoting_style,
106
107 /* Quote names as for a C language string (ls --quoting-style=c).
108 Behaves like c_maybe_quoting_style if QA_ELIDE_OUTER_QUOTES is
109 in effect. Split into consecutive strings if
110 QA_SPLIT_TRIGRAPHS.
111
112 quotearg_buffer:
113 "\"simple\"", "\"\\0 \\t\\n'\\\"\\033??/\\\\\"", "\"a:b\""
114 quotearg:
115 "\"simple\"", "\"\\0 \\t\\n'\\\"\\033??/\\\\\"", "\"a:b\""
116 quotearg_colon:
117 "\"simple\"", "\"\\0 \\t\\n'\\\"\\033??/\\\\\"", "\"a\\:b\""
118 */
119 c_quoting_style,
120
121 /* Like c_quoting_style except omit the surrounding double-quote
122 characters if no quoted characters are encountered.
123
124 quotearg_buffer:
125 "simple", "\"\\0 \\t\\n'\\\"\\033??/\\\\\"", "a:b"
126 quotearg:
127 "simple", "\"\\0 \\t\\n'\\\"\\033??/\\\\\"", "a:b"
128 quotearg_colon:
129 "simple", "\"\\0 \\t\\n'\\\"\\033??/\\\\\"", "\"a:b\""
130 */
131 c_maybe_quoting_style,
132
133 /* Like c_quoting_style except always omit the surrounding
134 double-quote characters and ignore QA_SPLIT_TRIGRAPHS
135 (ls --quoting-style=escape).
136
137 quotearg_buffer:
138 "simple", "\\0 \\t\\n'\"\\033??/\\\\", "a:b"
139 quotearg:
140 "simple", "\\0 \\t\\n'\"\\033??/\\\\", "a:b"
141 quotearg_colon:
142 "simple", "\\0 \\t\\n'\"\\033??/\\\\", "a\\:b"
143 */
144 escape_quoting_style,
145
146 /* Like clocale_quoting_style, but use single quotes in the
147 default C locale or if the program does not use gettext
148 (ls --quoting-style=locale). For UTF-8 locales, quote
149 characters will use Unicode.
150
151 LC_MESSAGES=C
152 quotearg_buffer:
153 "`simple'", "`\\0 \\t\\n\\'\"\\033??/\\\\'", "`a:b'"
154 quotearg:
155 "`simple'", "`\\0 \\t\\n\\'\"\\033??/\\\\'", "`a:b'"
156 quotearg_colon:
157 "`simple'", "`\\0 \\t\\n\\'\"\\033??/\\\\'", "`a\\:b'"
158
159 LC_MESSAGES=pt_PT.utf8
160 quotearg_buffer:
161 "\302\253simple\302\273",
162 "\302\253\\0 \\t\\n'\"\\033??/\\\\\302\253", "\302\253a:b\302\273"
163 quotearg:
164 "\302\253simple\302\273",
165 "\302\253\\0 \\t\\n'\"\\033??/\\\\\302\253", "\302\253a:b\302\273"
166 quotearg_colon:
167 "\302\253simple\302\273",
168 "\302\253\\0 \\t\\n'\"\\033??/\\\\\302\253", "\302\253a\\:b\302\273"
169 */
170 locale_quoting_style,
171
172 /* Like c_quoting_style except use quotation marks appropriate for
173 the locale and ignore QA_SPLIT_TRIGRAPHS
174 (ls --quoting-style=clocale).
175
176 LC_MESSAGES=C
177 quotearg_buffer:
178 "\"simple\"", "\"\\0 \\t\\n'\\\"\\033??/\\\\\"", "\"a:b\""
179 quotearg:
180 "\"simple\"", "\"\\0 \\t\\n'\\\"\\033??/\\\\\"", "\"a:b\""
181 quotearg_colon:
182 "\"simple\"", "\"\\0 \\t\\n'\\\"\\033??/\\\\\"", "\"a\\:b\""
183
184 LC_MESSAGES=pt_PT.utf8
185 quotearg_buffer:
186 "\302\253simple\302\273",
187 "\302\253\\0 \\t\\n'\"\\033??/\\\\\302\253", "\302\253a:b\302\273"
188 quotearg:
189 "\302\253simple\302\273",
190 "\302\253\\0 \\t\\n'\"\\033??/\\\\\302\253", "\302\253a:b\302\273"
191 quotearg_colon:
192 "\302\253simple\302\273",
193 "\302\253\\0 \\t\\n'\"\\033??/\\\\\302\253", "\302\253a\\:b\302\273"
194 */
195 clocale_quoting_style,
196
197 /* Like clocale_quoting_style except use the custom quotation marks
198 set by set_custom_quoting. If custom quotation marks are not
199 set, the behavior is undefined.
200
201 left_quote = right_quote = "'"
202 quotearg_buffer:
203 "'simple'", "'\\0 \\t\\n\\'\"\\033??/\\\\'", "'a:b'"
204 quotearg:
205 "'simple'", "'\\0 \\t\\n\\'\"\\033??/\\\\'", "'a:b'"
206 quotearg_colon:
207 "'simple'", "'\\0 \\t\\n\\'\"\\033??/\\\\'", "'a\\:b'"
208
209 left_quote = "(" and right_quote = ")"
210 quotearg_buffer:
211 "(simple)", "(\\0 \\t\\n'\"\\033??/\\\\)", "(a:b)"
212 quotearg:
213 "(simple)", "(\\0 \\t\\n'\"\\033??/\\\\)", "(a:b)"
214 quotearg_colon:
215 "(simple)", "(\\0 \\t\\n'\"\\033??/\\\\)", "(a\\:b)"
216
217 left_quote = ":" and right_quote = " "
218 quotearg_buffer:
219 ":simple ", ":\\0\\ \\t\\n'\"\\033??/\\\\ ", ":a:b "
220 quotearg:
221 ":simple ", ":\\0\\ \\t\\n'\"\\033??/\\\\ ", ":a:b "
222 quotearg_colon:
223 ":simple ", ":\\0\\ \\t\\n'\"\\033??/\\\\ ", ":a\\:b "
224
225 left_quote = "\"'" and right_quote = "'\""
226 Notice that this is treated as a single level of quotes or two
227 levels where the outer quote need not be escaped within the inner
228 quotes. For two levels where the outer quote must be escaped
229 within the inner quotes, you must use separate quotearg
230 invocations.
231 quotearg_buffer:
232 "\"'simple'\"", "\"'\\0 \\t\\n\\'\"\\033??/\\\\'\"", "\"'a:b'\""
233 quotearg:
234 "\"'simple'\"", "\"'\\0 \\t\\n\\'\"\\033??/\\\\'\"", "\"'a:b'\""
235 quotearg_colon:
236 "\"'simple'\"", "\"'\\0 \\t\\n\\'\"\\033??/\\\\'\"", "\"'a\\:b'\""
237 */
238 custom_quoting_style
239 };
240
241 /* Flags for use in set_quoting_flags. */
242 enum quoting_flags
243 {
244 /* Always elide null bytes from styles that do not quote them,
245 even when the length of the result is available to the
246 caller. */
247 QA_ELIDE_NULL_BYTES = 0x01,
248
249 /* Omit the surrounding quote characters if no escaped characters
250 are encountered. Note that if no other character needs
251 escaping, then neither does the escape character. */
252 QA_ELIDE_OUTER_QUOTES = 0x02,
253
254 /* In the c_quoting_style and c_maybe_quoting_style, split ANSI
255 trigraph sequences into concatenated strings (for example,
256 "?""?/" rather than "??/", which could be confused with
257 "\\"). */
258 QA_SPLIT_TRIGRAPHS = 0x04
259 };
260
261 /* For now, --quoting-style=literal is the default, but this may change. */
262 # ifndef DEFAULT_QUOTING_STYLE
263 # define DEFAULT_QUOTING_STYLE literal_quoting_style
264 # endif
265
266 /* Names of quoting styles and their corresponding values. */
267 extern char const *const quoting_style_args[];
268 extern enum quoting_style const quoting_style_vals[];
269
270 struct quoting_options;
271
272 /* The functions listed below set and use a hidden variable
273 that contains the default quoting style options. */
274
275 /* Allocate a new set of quoting options, with contents initially identical
276 to O if O is not null, or to the default if O is null.
277 It is the caller's responsibility to free the result. */
278 struct quoting_options *clone_quoting_options (struct quoting_options *o)
279 _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE
280 _GL_ATTRIBUTE_RETURNS_NONNULL;
281
282 /* Get the value of O's quoting style. If O is null, use the default. */
283 enum quoting_style get_quoting_style (struct quoting_options const *o);
284
285 /* In O (or in the default if O is null),
286 set the value of the quoting style to S. */
287 void set_quoting_style (struct quoting_options *o, enum quoting_style s);
288
289 /* In O (or in the default if O is null),
290 set the value of the quoting options for character C to I.
291 Return the old value. Currently, the only values defined for I are
292 0 (the default) and 1 (which means to quote the character even if
293 it would not otherwise be quoted). C must never be a digit or a
294 letter that has special meaning after a backslash (for example, "\t"
295 for tab). */
296 int set_char_quoting (struct quoting_options *o, char c, int i);
297
298 /* In O (or in the default if O is null),
299 set the value of the quoting options flag to I, which can be a
300 bitwise combination of enum quoting_flags, or 0 for default
301 behavior. Return the old value. */
302 int set_quoting_flags (struct quoting_options *o, int i);
303
304 /* In O (or in the default if O is null),
305 set the value of the quoting style to custom_quoting_style,
306 set the left quote to LEFT_QUOTE, and set the right quote to
307 RIGHT_QUOTE. Each of LEFT_QUOTE and RIGHT_QUOTE must be
308 null-terminated and can be the empty string. Because backslashes are
309 used for escaping, it does not make sense for RIGHT_QUOTE to contain
310 a backslash. RIGHT_QUOTE must not begin with a digit or a letter
311 that has special meaning after a backslash (for example, "\t" for
312 tab). */
313 void set_custom_quoting (struct quoting_options *o,
314 char const *left_quote,
315 char const *right_quote);
316
317 /* Place into buffer BUFFER (of size BUFFERSIZE) a quoted version of
318 argument ARG (of size ARGSIZE), using O to control quoting.
319 If O is null, use the default.
320 Terminate the output with a null character, and return the written
321 size of the output, not counting the terminating null.
322 If BUFFERSIZE is too small to store the output string, return the
323 value that would have been returned had BUFFERSIZE been large enough.
324 If ARGSIZE is -1, use the string length of the argument for ARGSIZE.
325 On output, BUFFER might contain embedded null bytes if ARGSIZE was
326 not -1, the style of O does not use backslash escapes, and the
327 flags of O do not request elision of null bytes.*/
328 size_t quotearg_buffer (char *restrict buffer, size_t buffersize,
329 char const *arg, size_t argsize,
330 struct quoting_options const *o);
331
332 /* Like quotearg_buffer, except return the result in a newly allocated
333 buffer. It is the caller's responsibility to free the result. The
334 result will not contain embedded null bytes. */
335 char *quotearg_alloc (char const *arg, size_t argsize,
336 struct quoting_options const *o)
337 _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE
338 _GL_ATTRIBUTE_RETURNS_NONNULL;
339
340 /* Like quotearg_alloc, except that the length of the result,
341 excluding the terminating null byte, is stored into SIZE if it is
342 non-NULL. The result might contain embedded null bytes if ARGSIZE
343 was not -1, SIZE was not NULL, the style of O does not use
344 backslash escapes, and the flags of O do not request elision of
345 null bytes.*/
346 char *quotearg_alloc_mem (char const *arg, size_t argsize,
347 size_t *size, struct quoting_options const *o)
348 _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE
349 _GL_ATTRIBUTE_RETURNS_NONNULL;
350
351 /* Use storage slot N to return a quoted version of the string ARG.
352 Use the default quoting options.
353 The returned value points to static storage that can be
354 reused by the next call to this function with the same value of N.
355 N must be nonnegative. The output of all functions in the
356 quotearg_n family are guaranteed to not contain embedded null
357 bytes.*/
358 char *quotearg_n (int n, char const *arg);
359
360 /* Equivalent to quotearg_n (0, ARG). */
361 char *quotearg (char const *arg);
362
363 /* Use storage slot N to return a quoted version of the argument ARG
364 of size ARGSIZE. This is like quotearg_n (N, ARG), except it can
365 quote null bytes. */
366 char *quotearg_n_mem (int n, char const *arg, size_t argsize);
367
368 /* Equivalent to quotearg_n_mem (0, ARG, ARGSIZE). */
369 char *quotearg_mem (char const *arg, size_t argsize);
370
371 /* Use style S and storage slot N to return a quoted version of the string ARG.
372 This is like quotearg_n (N, ARG), except that it uses S with no other
373 options to specify the quoting method. */
374 char *quotearg_n_style (int n, enum quoting_style s, char const *arg);
375
376 /* Use style S and storage slot N to return a quoted version of the
377 argument ARG of size ARGSIZE. This is like quotearg_n_style
378 (N, S, ARG), except it can quote null bytes. */
379 char *quotearg_n_style_mem (int n, enum quoting_style s,
380 char const *arg, size_t argsize);
381
382 /* Equivalent to quotearg_n_style (0, S, ARG). */
383 char *quotearg_style (enum quoting_style s, char const *arg);
384
385 /* Equivalent to quotearg_n_style_mem (0, S, ARG, ARGSIZE). */
386 char *quotearg_style_mem (enum quoting_style s,
387 char const *arg, size_t argsize);
388
389 /* Like quotearg (ARG), except also quote any instances of CH.
390 See set_char_quoting for a description of acceptable CH values. */
391 char *quotearg_char (char const *arg, char ch);
392
393 /* Like quotearg_char (ARG, CH), except it can quote null bytes. */
394 char *quotearg_char_mem (char const *arg, size_t argsize, char ch);
395
396 /* Equivalent to quotearg_char (ARG, ':'). */
397 char *quotearg_colon (char const *arg);
398
399 /* Like quotearg_colon (ARG), except it can quote null bytes. */
400 char *quotearg_colon_mem (char const *arg, size_t argsize);
401
402 /* Like quotearg_n_style, except with ':' quoting enabled. */
403 char *quotearg_n_style_colon (int n, enum quoting_style s, char const *arg);
404
405 /* Like quotearg_n_style (N, S, ARG) but with S as custom_quoting_style
406 with left quote as LEFT_QUOTE and right quote as RIGHT_QUOTE. See
407 set_custom_quoting for a description of acceptable LEFT_QUOTE and
408 RIGHT_QUOTE values. */
409 char *quotearg_n_custom (int n, char const *left_quote,
410 char const *right_quote, char const *arg);
411
412 /* Like quotearg_n_custom (N, LEFT_QUOTE, RIGHT_QUOTE, ARG) except it
413 can quote null bytes. */
414 char *quotearg_n_custom_mem (int n, char const *left_quote,
415 char const *right_quote,
416 char const *arg, size_t argsize);
417
418 /* Equivalent to quotearg_n_custom (0, LEFT_QUOTE, RIGHT_QUOTE, ARG). */
419 char *quotearg_custom (char const *left_quote, char const *right_quote,
420 char const *arg);
421
422 /* Equivalent to quotearg_n_custom_mem (0, LEFT_QUOTE, RIGHT_QUOTE, ARG,
423 ARGSIZE). */
424 char *quotearg_custom_mem (char const *left_quote,
425 char const *right_quote,
426 char const *arg, size_t argsize);
427
428 /* Free any dynamically allocated memory. */
429 void quotearg_free (void);
430
431 #endif /* !QUOTEARG_H_ */