quotearg.h revision 05436638acc7c010349a69c3395f1a57c642dc62 
1/* quotearg.h - quote arguments for output
2
3   Copyright (C) 1998-2002, 2004, 2006, 2008-2012 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 <http://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 <stddef.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 "\\").  */
32enum 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 as for a C language string (ls --quoting-style=c).
77       Behaves like c_maybe_quoting_style if QA_ELIDE_OUTER_QUOTES is
78       in effect.  Split into consecutive strings if
79       QA_SPLIT_TRIGRAPHS.
80
81       quotearg_buffer:
82       "\"simple\"", "\"\\0 \\t\\n'\\\"\\033??/\\\\\"", "\"a:b\""
83       quotearg:
84       "\"simple\"", "\"\\0 \\t\\n'\\\"\\033??/\\\\\"", "\"a:b\""
85       quotearg_colon:
86       "\"simple\"", "\"\\0 \\t\\n'\\\"\\033??/\\\\\"", "\"a\\:b\""
87    */
88    c_quoting_style,
89
90    /* Like c_quoting_style except omit the surrounding double-quote
91       characters if no quoted characters are encountered.
92
93       quotearg_buffer:
94       "simple", "\"\\0 \\t\\n'\\\"\\033??/\\\\\"", "a:b"
95       quotearg:
96       "simple", "\"\\0 \\t\\n'\\\"\\033??/\\\\\"", "a:b"
97       quotearg_colon:
98       "simple", "\"\\0 \\t\\n'\\\"\\033??/\\\\\"", "\"a:b\""
99    */
100    c_maybe_quoting_style,
101
102    /* Like c_quoting_style except always omit the surrounding
103       double-quote characters and ignore QA_SPLIT_TRIGRAPHS
104       (ls --quoting-style=escape).
105
106       quotearg_buffer:
107       "simple", "\\0 \\t\\n'\"\\033??/\\\\", "a:b"
108       quotearg:
109       "simple", "\\0 \\t\\n'\"\\033??/\\\\", "a:b"
110       quotearg_colon:
111       "simple", "\\0 \\t\\n'\"\\033??/\\\\", "a\\:b"
112    */
113    escape_quoting_style,
114
115    /* Like clocale_quoting_style, but use single quotes in the
116       default C locale or if the program does not use gettext
117       (ls --quoting-style=locale).  For UTF-8 locales, quote
118       characters will use Unicode.
119
120       LC_MESSAGES=C
121       quotearg_buffer:
122       "`simple'", "`\\0 \\t\\n\\'\"\\033??/\\\\'", "`a:b'"
123       quotearg:
124       "`simple'", "`\\0 \\t\\n\\'\"\\033??/\\\\'", "`a:b'"
125       quotearg_colon:
126       "`simple'", "`\\0 \\t\\n\\'\"\\033??/\\\\'", "`a\\:b'"
127
128       LC_MESSAGES=pt_PT.utf8
129       quotearg_buffer:
130       "\302\253simple\302\273",
131       "\302\253\\0 \\t\\n'\"\\033??/\\\\\302\253", "\302\253a:b\302\273"
132       quotearg:
133       "\302\253simple\302\273",
134       "\302\253\\0 \\t\\n'\"\\033??/\\\\\302\253", "\302\253a:b\302\273"
135       quotearg_colon:
136       "\302\253simple\302\273",
137       "\302\253\\0 \\t\\n'\"\\033??/\\\\\302\253", "\302\253a\\:b\302\273"
138    */
139    locale_quoting_style,
140
141    /* Like c_quoting_style except use quotation marks appropriate for
142       the locale and ignore QA_SPLIT_TRIGRAPHS
143       (ls --quoting-style=clocale).
144
145       LC_MESSAGES=C
146       quotearg_buffer:
147       "\"simple\"", "\"\\0 \\t\\n'\\\"\\033??/\\\\\"", "\"a:b\""
148       quotearg:
149       "\"simple\"", "\"\\0 \\t\\n'\\\"\\033??/\\\\\"", "\"a:b\""
150       quotearg_colon:
151       "\"simple\"", "\"\\0 \\t\\n'\\\"\\033??/\\\\\"", "\"a\\:b\""
152
153       LC_MESSAGES=pt_PT.utf8
154       quotearg_buffer:
155       "\302\253simple\302\273",
156       "\302\253\\0 \\t\\n'\"\\033??/\\\\\302\253", "\302\253a:b\302\273"
157       quotearg:
158       "\302\253simple\302\273",
159       "\302\253\\0 \\t\\n'\"\\033??/\\\\\302\253", "\302\253a:b\302\273"
160       quotearg_colon:
161       "\302\253simple\302\273",
162       "\302\253\\0 \\t\\n'\"\\033??/\\\\\302\253", "\302\253a\\:b\302\273"
163    */
164    clocale_quoting_style,
165
166    /* Like clocale_quoting_style except use the custom quotation marks
167       set by set_custom_quoting.  If custom quotation marks are not
168       set, the behavior is undefined.
169
170       left_quote = right_quote = "'"
171       quotearg_buffer:
172       "'simple'", "'\\0 \\t\\n\\'\"\\033??/\\\\'", "'a:b'"
173       quotearg:
174       "'simple'", "'\\0 \\t\\n\\'\"\\033??/\\\\'", "'a:b'"
175       quotearg_colon:
176       "'simple'", "'\\0 \\t\\n\\'\"\\033??/\\\\'", "'a\\:b'"
177
178       left_quote = "(" and right_quote = ")"
179       quotearg_buffer:
180       "(simple)", "(\\0 \\t\\n'\"\\033??/\\\\)", "(a:b)"
181       quotearg:
182       "(simple)", "(\\0 \\t\\n'\"\\033??/\\\\)", "(a:b)"
183       quotearg_colon:
184       "(simple)", "(\\0 \\t\\n'\"\\033??/\\\\)", "(a\\:b)"
185
186       left_quote = ":" and right_quote = " "
187       quotearg_buffer:
188       ":simple ", ":\\0\\ \\t\\n'\"\\033??/\\\\ ", ":a:b "
189       quotearg:
190       ":simple ", ":\\0\\ \\t\\n'\"\\033??/\\\\ ", ":a:b "
191       quotearg_colon:
192       ":simple ", ":\\0\\ \\t\\n'\"\\033??/\\\\ ", ":a\\:b "
193
194       left_quote = "\"'" and right_quote = "'\""
195       Notice that this is treated as a single level of quotes or two
196       levels where the outer quote need not be escaped within the inner
197       quotes.  For two levels where the outer quote must be escaped
198       within the inner quotes, you must use separate quotearg
199       invocations.
200       quotearg_buffer:
201       "\"'simple'\"", "\"'\\0 \\t\\n\\'\"\\033??/\\\\'\"", "\"'a:b'\""
202       quotearg:
203       "\"'simple'\"", "\"'\\0 \\t\\n\\'\"\\033??/\\\\'\"", "\"'a:b'\""
204       quotearg_colon:
205       "\"'simple'\"", "\"'\\0 \\t\\n\\'\"\\033??/\\\\'\"", "\"'a\\:b'\""
206    */
207    custom_quoting_style
208  };
209
210/* Flags for use in set_quoting_flags.  */
211enum quoting_flags
212  {
213    /* Always elide null bytes from styles that do not quote them,
214       even when the length of the result is available to the
215       caller.  */
216    QA_ELIDE_NULL_BYTES = 0x01,
217
218    /* Omit the surrounding quote characters if no escaped characters
219       are encountered.  Note that if no other character needs
220       escaping, then neither does the escape character.  */
221    QA_ELIDE_OUTER_QUOTES = 0x02,
222
223    /* In the c_quoting_style and c_maybe_quoting_style, split ANSI
224       trigraph sequences into concatenated strings (for example,
225       "?""?/" rather than "??/", which could be confused with
226       "\\").  */
227    QA_SPLIT_TRIGRAPHS = 0x04
228  };
229
230/* For now, --quoting-style=literal is the default, but this may change.  */
231# ifndef DEFAULT_QUOTING_STYLE
232#  define DEFAULT_QUOTING_STYLE literal_quoting_style
233# endif
234
235/* Names of quoting styles and their corresponding values.  */
236extern char const *const quoting_style_args[];
237extern enum quoting_style const quoting_style_vals[];
238
239struct quoting_options;
240
241/* The functions listed below set and use a hidden variable
242   that contains the default quoting style options.  */
243
244/* Allocate a new set of quoting options, with contents initially identical
245   to O if O is not null, or to the default if O is null.
246   It is the caller's responsibility to free the result.  */
247struct quoting_options *clone_quoting_options (struct quoting_options *o);
248
249/* Get the value of O's quoting style.  If O is null, use the default.  */
250enum quoting_style get_quoting_style (struct quoting_options *o);
251
252/* In O (or in the default if O is null),
253   set the value of the quoting style to S.  */
254void set_quoting_style (struct quoting_options *o, enum quoting_style s);
255
256/* In O (or in the default if O is null),
257   set the value of the quoting options for character C to I.
258   Return the old value.  Currently, the only values defined for I are
259   0 (the default) and 1 (which means to quote the character even if
260   it would not otherwise be quoted).  C must never be a digit or a
261   letter that has special meaning after a backslash (for example, "\t"
262   for tab).  */
263int set_char_quoting (struct quoting_options *o, char c, int i);
264
265/* In O (or in the default if O is null),
266   set the value of the quoting options flag to I, which can be a
267   bitwise combination of enum quoting_flags, or 0 for default
268   behavior.  Return the old value.  */
269int set_quoting_flags (struct quoting_options *o, int i);
270
271/* In O (or in the default if O is null),
272   set the value of the quoting style to custom_quoting_style,
273   set the left quote to LEFT_QUOTE, and set the right quote to
274   RIGHT_QUOTE.  Each of LEFT_QUOTE and RIGHT_QUOTE must be
275   null-terminated and can be the empty string.  Because backslashes are
276   used for escaping, it does not make sense for RIGHT_QUOTE to contain
277   a backslash.  RIGHT_QUOTE must not begin with a digit or a letter
278   that has special meaning after a backslash (for example, "\t" for
279   tab).  */
280void set_custom_quoting (struct quoting_options *o,
281                         char const *left_quote,
282                         char const *right_quote);
283
284/* Place into buffer BUFFER (of size BUFFERSIZE) a quoted version of
285   argument ARG (of size ARGSIZE), using O to control quoting.
286   If O is null, use the default.
287   Terminate the output with a null character, and return the written
288   size of the output, not counting the terminating null.
289   If BUFFERSIZE is too small to store the output string, return the
290   value that would have been returned had BUFFERSIZE been large enough.
291   If ARGSIZE is -1, use the string length of the argument for ARGSIZE.
292   On output, BUFFER might contain embedded null bytes if ARGSIZE was
293   not -1, the style of O does not use backslash escapes, and the
294   flags of O do not request elision of null bytes.*/
295size_t quotearg_buffer (char *buffer, size_t buffersize,
296                        char const *arg, size_t argsize,
297                        struct quoting_options const *o);
298
299/* Like quotearg_buffer, except return the result in a newly allocated
300   buffer.  It is the caller's responsibility to free the result.  The
301   result will not contain embedded null bytes.  */
302char *quotearg_alloc (char const *arg, size_t argsize,
303                      struct quoting_options const *o);
304
305/* Like quotearg_alloc, except that the length of the result,
306   excluding the terminating null byte, is stored into SIZE if it is
307   non-NULL.  The result might contain embedded null bytes if ARGSIZE
308   was not -1, SIZE was not NULL, the style of O does not use
309   backslash escapes, and the flags of O do not request elision of
310   null bytes.*/
311char *quotearg_alloc_mem (char const *arg, size_t argsize,
312                          size_t *size, struct quoting_options const *o);
313
314/* Use storage slot N to return a quoted version of the string ARG.
315   Use the default quoting options.
316   The returned value points to static storage that can be
317   reused by the next call to this function with the same value of N.
318   N must be nonnegative.  The output of all functions in the
319   quotearg_n family are guaranteed to not contain embedded null
320   bytes.*/
321char *quotearg_n (int n, char const *arg);
322
323/* Equivalent to quotearg_n (0, ARG).  */
324char *quotearg (char const *arg);
325
326/* Use storage slot N to return a quoted version of the argument ARG
327   of size ARGSIZE.  This is like quotearg_n (N, ARG), except it can
328   quote null bytes.  */
329char *quotearg_n_mem (int n, char const *arg, size_t argsize);
330
331/* Equivalent to quotearg_n_mem (0, ARG, ARGSIZE).  */
332char *quotearg_mem (char const *arg, size_t argsize);
333
334/* Use style S and storage slot N to return a quoted version of the string ARG.
335   This is like quotearg_n (N, ARG), except that it uses S with no other
336   options to specify the quoting method.  */
337char *quotearg_n_style (int n, enum quoting_style s, char const *arg);
338
339/* Use style S and storage slot N to return a quoted version of the
340   argument ARG of size ARGSIZE.  This is like quotearg_n_style
341   (N, S, ARG), except it can quote null bytes.  */
342char *quotearg_n_style_mem (int n, enum quoting_style s,
343                            char const *arg, size_t argsize);
344
345/* Equivalent to quotearg_n_style (0, S, ARG).  */
346char *quotearg_style (enum quoting_style s, char const *arg);
347
348/* Equivalent to quotearg_n_style_mem (0, S, ARG, ARGSIZE).  */
349char *quotearg_style_mem (enum quoting_style s,
350                          char const *arg, size_t argsize);
351
352/* Like quotearg (ARG), except also quote any instances of CH.
353   See set_char_quoting for a description of acceptable CH values.  */
354char *quotearg_char (char const *arg, char ch);
355
356/* Like quotearg_char (ARG, CH), except it can quote null bytes.  */
357char *quotearg_char_mem (char const *arg, size_t argsize, char ch);
358
359/* Equivalent to quotearg_char (ARG, ':').  */
360char *quotearg_colon (char const *arg);
361
362/* Like quotearg_colon (ARG), except it can quote null bytes.  */
363char *quotearg_colon_mem (char const *arg, size_t argsize);
364
365/* Like quotearg_n_style (N, S, ARG) but with S as custom_quoting_style
366   with left quote as LEFT_QUOTE and right quote as RIGHT_QUOTE.  See
367   set_custom_quoting for a description of acceptable LEFT_QUOTE and
368   RIGHT_QUOTE values.  */
369char *quotearg_n_custom (int n, char const *left_quote,
370                         char const *right_quote, char const *arg);
371
372/* Like quotearg_n_custom (N, LEFT_QUOTE, RIGHT_QUOTE, ARG) except it
373   can quote null bytes.  */
374char *quotearg_n_custom_mem (int n, char const *left_quote,
375                             char const *right_quote,
376                             char const *arg, size_t argsize);
377
378/* Equivalent to quotearg_n_custom (0, LEFT_QUOTE, RIGHT_QUOTE, ARG).  */
379char *quotearg_custom (char const *left_quote, char const *right_quote,
380                       char const *arg);
381
382/* Equivalent to quotearg_n_custom_mem (0, LEFT_QUOTE, RIGHT_QUOTE, ARG,
383                                        ARGSIZE).  */
384char *quotearg_custom_mem (char const *left_quote,
385                           char const *right_quote,
386                           char const *arg, size_t argsize);
387
388/* Free any dynamically allocated memory.  */
389void quotearg_free (void);
390
391#endif /* !QUOTEARG_H_ */
392