1 /* quotearg.c - quote arguments for output
2
3 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2004, 2005, 2006, 2007 Free
4 Software Foundation, 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 2, or (at your option)
9 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, write to the Free Software Foundation,
18 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
19
20 /* Written by Paul Eggert <eggert@twinsun.com> */
21
22 #include <config.h>
23
24 #include "quotearg.h"
25
26 #include "xalloc.h"
27
28 #include <ctype.h>
29 #include <errno.h>
30 #include <limits.h>
31 #include <stdbool.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #include <wchar.h>
35 #include <wctype.h>
36
37 #include "gettext.h"
38 #define _(msgid) gettext (msgid)
39 #define N_(msgid) msgid
40
41 #if !HAVE_MBRTOWC
42 /* Disable multibyte processing entirely. Since MB_CUR_MAX is 1, the
43 other macros are defined only for documentation and to satisfy C
44 syntax. */
45 # undef MB_CUR_MAX
46 # define MB_CUR_MAX 1
47 # undef mbstate_t
48 # define mbstate_t int
49 # define mbrtowc(pwc, s, n, ps) ((*(pwc) = *(s)) != 0)
50 # define iswprint(wc) isprint ((unsigned char) (wc))
51 # undef HAVE_MBSINIT
52 #endif
53
54 #if !defined mbsinit && !HAVE_MBSINIT
55 # define mbsinit(ps) 1
56 #endif
57
58 #ifndef SIZE_MAX
59 # define SIZE_MAX ((size_t) -1)
60 #endif
61
62 #define INT_BITS (sizeof (int) * CHAR_BIT)
63
64 struct quoting_options
65 {
66 /* Basic quoting style. */
67 enum quoting_style style;
68
69 /* Quote the characters indicated by this bit vector even if the
70 quoting style would not normally require them to be quoted. */
71 unsigned int quote_these_too[(UCHAR_MAX / INT_BITS) + 1];
72 };
73
74 /* Names of quoting styles. */
75 char const *const quoting_style_args[] =
76 {
77 "literal",
78 "shell",
79 "shell-always",
80 "c",
81 "escape",
82 "locale",
83 "clocale",
84 0
85 };
86
87 /* Correspondences to quoting style names. */
88 enum quoting_style const quoting_style_vals[] =
89 {
90 literal_quoting_style,
91 shell_quoting_style,
92 shell_always_quoting_style,
93 c_quoting_style,
94 escape_quoting_style,
95 locale_quoting_style,
96 clocale_quoting_style
97 };
98
99 /* The default quoting options. */
100 static struct quoting_options default_quoting_options;
101
102 /* Allocate a new set of quoting options, with contents initially identical
103 to O if O is not null, or to the default if O is null.
104 It is the caller's responsibility to free the result. */
105 struct quoting_options *
106 clone_quoting_options (struct quoting_options *o)
107 {
108 int e = errno;
109 struct quoting_options *p = xmemdup (o ? o : &default_quoting_options,
110 sizeof *o);
111 errno = e;
112 return p;
113 }
114
115 /* Get the value of O's quoting style. If O is null, use the default. */
116 enum quoting_style
117 get_quoting_style (struct quoting_options *o)
118 {
119 return (o ? o : &default_quoting_options)->style;
120 }
121
122 /* In O (or in the default if O is null),
123 set the value of the quoting style to S. */
124 void
125 set_quoting_style (struct quoting_options *o, enum quoting_style s)
126 {
127 (o ? o : &default_quoting_options)->style = s;
128 }
129
130 /* In O (or in the default if O is null),
131 set the value of the quoting options for character C to I.
132 Return the old value. Currently, the only values defined for I are
133 0 (the default) and 1 (which means to quote the character even if
134 it would not otherwise be quoted). */
135 int
136 set_char_quoting (struct quoting_options *o, char c, int i)
137 {
138 unsigned char uc = c;
139 unsigned int *p =
140 (o ? o : &default_quoting_options)->quote_these_too + uc / INT_BITS;
141 int shift = uc % INT_BITS;
142 int r = (*p >> shift) & 1;
143 *p ^= ((i & 1) ^ r) << shift;
144 return r;
145 }
146
147 /* MSGID approximates a quotation mark. Return its translation if it
148 has one; otherwise, return either it or "\"", depending on S. */
149 static char const *
150 gettext_quote (char const *msgid, enum quoting_style s)
151 {
152 char const *translation = _(msgid);
153 if (translation == msgid && s == clocale_quoting_style)
154 translation = "\"";
155 return translation;
156 }
157
158 /* Place into buffer BUFFER (of size BUFFERSIZE) a quoted version of
159 argument ARG (of size ARGSIZE), using QUOTING_STYLE and the
160 non-quoting-style part of O to control quoting.
161 Terminate the output with a null character, and return the written
162 size of the output, not counting the terminating null.
163 If BUFFERSIZE is too small to store the output string, return the
164 value that would have been returned had BUFFERSIZE been large enough.
165 If ARGSIZE is SIZE_MAX, use the string length of the argument for ARGSIZE.
166
167 This function acts like quotearg_buffer (BUFFER, BUFFERSIZE, ARG,
168 ARGSIZE, O), except it uses QUOTING_STYLE instead of the quoting
169 style specified by O, and O may not be null. */
170
171 static size_t
172 quotearg_buffer_restyled (char *buffer, size_t buffersize,
173 char const *arg, size_t argsize,
174 enum quoting_style quoting_style,
175 struct quoting_options const *o)
176 {
177 size_t i;
178 size_t len = 0;
179 char const *quote_string = 0;
180 size_t quote_string_len = 0;
181 bool backslash_escapes = false;
182 bool unibyte_locale = MB_CUR_MAX == 1;
183
184 #define STORE(c) \
185 do \
186 { \
187 if (len < buffersize) \
188 buffer[len] = (c); \
189 len++; \
190 } \
191 while (0)
192
193 switch (quoting_style)
194 {
195 case c_quoting_style:
196 STORE ('"');
197 backslash_escapes = true;
198 quote_string = "\"";
199 quote_string_len = 1;
200 break;
201
202 case escape_quoting_style:
203 backslash_escapes = true;
204 break;
205
206 case locale_quoting_style:
207 case clocale_quoting_style:
208 {
209 /* TRANSLATORS:
210 Get translations for open and closing quotation marks.
211
212 The message catalog should translate "`" to a left
213 quotation mark suitable for the locale, and similarly for
214 "'". If the catalog has no translation,
215 locale_quoting_style quotes `like this', and
216 clocale_quoting_style quotes "like this".
217
218 For example, an American English Unicode locale should
219 translate "`" to U+201C (LEFT DOUBLE QUOTATION MARK), and
220 should translate "'" to U+201D (RIGHT DOUBLE QUOTATION
221 MARK). A British English Unicode locale should instead
222 translate these to U+2018 (LEFT SINGLE QUOTATION MARK) and
223 U+2019 (RIGHT SINGLE QUOTATION MARK), respectively.
224
225 If you don't know what to put here, please see
226 <http://en.wikipedia.org/wiki/Quotation_mark#Glyphs>
227 and use glyphs suitable for your language. */
228
229 char const *left = gettext_quote (N_("`"), quoting_style);
230 char const *right = gettext_quote (N_("'"), quoting_style);
231 for (quote_string = left; *quote_string; quote_string++)
232 STORE (*quote_string);
233 backslash_escapes = true;
234 quote_string = right;
235 quote_string_len = strlen (quote_string);
236 }
237 break;
238
239 case shell_always_quoting_style:
240 STORE ('\'');
241 quote_string = "'";
242 quote_string_len = 1;
243 break;
244
245 default:
246 break;
247 }
248
249 for (i = 0; ! (argsize == SIZE_MAX ? arg[i] == '\0' : i == argsize); i++)
250 {
251 unsigned char c;
252 unsigned char esc;
253
254 if (backslash_escapes
255 && quote_string_len
256 && i + quote_string_len <= argsize
257 && memcmp (arg + i, quote_string, quote_string_len) == 0)
258 STORE ('\\');
259
260 c = arg[i];
261 switch (c)
262 {
263 case '\0':
264 if (backslash_escapes)
265 {
266 STORE ('\\');
267 STORE ('0');
268 STORE ('0');
269 c = '0';
270 }
271 break;
272
273 case '?':
274 switch (quoting_style)
275 {
276 case shell_quoting_style:
277 goto use_shell_always_quoting_style;
278
279 case c_quoting_style:
280 if (i + 2 < argsize && arg[i + 1] == '?')
281 switch (arg[i + 2])
282 {
283 case '!': case '\'':
284 case '(': case ')': case '-': case '/':
285 case '<': case '=': case '>':
286 /* Escape the second '?' in what would otherwise be
287 a trigraph. */
288 c = arg[i + 2];
289 i += 2;
290 STORE ('?');
291 STORE ('\\');
292 STORE ('?');
293 break;
294
295 default:
296 break;
297 }
298 break;
299
300 default:
301 break;
302 }
303 break;
304
305 case '\a': esc = 'a'; goto c_escape;
306 case '\b': esc = 'b'; goto c_escape;
307 case '\f': esc = 'f'; goto c_escape;
308 case '\n': esc = 'n'; goto c_and_shell_escape;
309 case '\r': esc = 'r'; goto c_and_shell_escape;
310 case '\t': esc = 't'; goto c_and_shell_escape;
311 case '\v': esc = 'v'; goto c_escape;
312 case '\\': esc = c; goto c_and_shell_escape;
313
314 c_and_shell_escape:
315 if (quoting_style == shell_quoting_style)
316 goto use_shell_always_quoting_style;
317 c_escape:
318 if (backslash_escapes)
319 {
320 c = esc;
321 goto store_escape;
322 }
323 break;
324
325 case '{': case '}': /* sometimes special if isolated */
326 if (! (argsize == SIZE_MAX ? arg[1] == '\0' : argsize == 1))
327 break;
328 /* Fall through. */
329 case '#': case '~':
330 if (i != 0)
331 break;
332 /* Fall through. */
333 case ' ':
334 case '!': /* special in bash */
335 case '"': case '$': case '&':
336 case '(': case ')': case '*': case ';':
337 case '<':
338 case '=': /* sometimes special in 0th or (with "set -k") later args */
339 case '>': case '[':
340 case '^': /* special in old /bin/sh, e.g. SunOS 4.1.4 */
341 case '`': case '|':
342 /* A shell special character. In theory, '$' and '`' could
343 be the first bytes of multibyte characters, which means
344 we should check them with mbrtowc, but in practice this
345 doesn't happen so it's not worth worrying about. */
346 if (quoting_style == shell_quoting_style)
347 goto use_shell_always_quoting_style;
348 break;
349
350 case '\'':
351 switch (quoting_style)
352 {
353 case shell_quoting_style:
354 goto use_shell_always_quoting_style;
355
356 case shell_always_quoting_style:
357 STORE ('\'');
358 STORE ('\\');
359 STORE ('\'');
360 break;
361
362 default:
363 break;
364 }
365 break;
366
367 case '%': case '+': case ',': case '-': case '.': case '/':
368 case '0': case '1': case '2': case '3': case '4': case '5':
369 case '6': case '7': case '8': case '9': case ':':
370 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
371 case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
372 case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
373 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
374 case 'Y': case 'Z': case ']': case '_': case 'a': case 'b':
375 case 'c': case 'd': case 'e': case 'f': case 'g': case 'h':
376 case 'i': case 'j': case 'k': case 'l': case 'm': case 'n':
377 case 'o': case 'p': case 'q': case 'r': case 's': case 't':
378 case 'u': case 'v': case 'w': case 'x': case 'y': case 'z':
379 /* These characters don't cause problems, no matter what the
380 quoting style is. They cannot start multibyte sequences. */
381 break;
382
383 default:
384 /* If we have a multibyte sequence, copy it until we reach
385 its end, find an error, or come back to the initial shift
386 state. For C-like styles, if the sequence has
387 unprintable characters, escape the whole sequence, since
388 we can't easily escape single characters within it. */
389 {
390 /* Length of multibyte sequence found so far. */
391 size_t m;
392
393 bool printable;
394
395 if (unibyte_locale)
396 {
397 m = 1;
398 printable = isprint (c) != 0;
399 }
400 else
401 {
402 mbstate_t mbstate;
403 memset (&mbstate, 0, sizeof mbstate);
404
405 m = 0;
406 printable = true;
407 if (argsize == SIZE_MAX)
408 argsize = strlen (arg);
409
410 do
411 {
412 wchar_t w;
413 size_t bytes = mbrtowc (&w, &arg[i + m],
414 argsize - (i + m), &mbstate);
415 if (bytes == 0)
416 break;
417 else if (bytes == (size_t) -1)
418 {
419 printable = false;
420 break;
421 }
422 else if (bytes == (size_t) -2)
423 {
424 printable = false;
425 while (i + m < argsize && arg[i + m])
426 m++;
427 break;
428 }
429 else
430 {
431 /* Work around a bug with older shells that "see" a '\'
432 that is really the 2nd byte of a multibyte character.
433 In practice the problem is limited to ASCII
434 chars >= '@' that are shell special chars. */
435 if ('[' == 0x5b && quoting_style == shell_quoting_style)
436 {
437 size_t j;
438 for (j = 1; j < bytes; j++)
439 switch (arg[i + m + j])
440 {
441 case '[': case '\\': case '^':
442 case '`': case '|':
443 goto use_shell_always_quoting_style;
444
445 default:
446 break;
447 }
448 }
449
450 if (! iswprint (w))
451 printable = false;
452 m += bytes;
453 }
454 }
455 while (! mbsinit (&mbstate));
456 }
457
458 if (1 < m || (backslash_escapes && ! printable))
459 {
460 /* Output a multibyte sequence, or an escaped
461 unprintable unibyte character. */
462 size_t ilim = i + m;
463
464 for (;;)
465 {
466 if (backslash_escapes && ! printable)
467 {
468 STORE ('\\');
469 STORE ('0' + (c >> 6));
470 STORE ('0' + ((c >> 3) & 7));
471 c = '0' + (c & 7);
472 }
473 if (ilim <= i + 1)
474 break;
475 STORE (c);
476 c = arg[++i];
477 }
478
479 goto store_c;
480 }
481 }
482 }
483
484 if (! (backslash_escapes
485 && o->quote_these_too[c / INT_BITS] & (1 << (c % INT_BITS))))
486 goto store_c;
487
488 store_escape:
489 STORE ('\\');
490
491 store_c:
492 STORE (c);
493 }
494
495 if (i == 0 && quoting_style == shell_quoting_style)
496 goto use_shell_always_quoting_style;
497
498 if (quote_string)
499 for (; *quote_string; quote_string++)
500 STORE (*quote_string);
501
502 if (len < buffersize)
503 buffer[len] = '\0';
504 return len;
505
506 use_shell_always_quoting_style:
507 return quotearg_buffer_restyled (buffer, buffersize, arg, argsize,
508 shell_always_quoting_style, o);
509 }
510
511 /* Place into buffer BUFFER (of size BUFFERSIZE) a quoted version of
512 argument ARG (of size ARGSIZE), using O to control quoting.
513 If O is null, use the default.
514 Terminate the output with a null character, and return the written
515 size of the output, not counting the terminating null.
516 If BUFFERSIZE is too small to store the output string, return the
517 value that would have been returned had BUFFERSIZE been large enough.
518 If ARGSIZE is SIZE_MAX, use the string length of the argument for
519 ARGSIZE. */
520 size_t
521 quotearg_buffer (char *buffer, size_t buffersize,
522 char const *arg, size_t argsize,
523 struct quoting_options const *o)
524 {
525 struct quoting_options const *p = o ? o : &default_quoting_options;
526 int e = errno;
527 size_t r = quotearg_buffer_restyled (buffer, buffersize, arg, argsize,
528 p->style, p);
529 errno = e;
530 return r;
531 }
532
533 /* Like quotearg_buffer (..., ARG, ARGSIZE, O), except return newly
534 allocated storage containing the quoted string. */
535 char *
536 quotearg_alloc (char const *arg, size_t argsize,
537 struct quoting_options const *o)
538 {
539 int e = errno;
540 size_t bufsize = quotearg_buffer (0, 0, arg, argsize, o) + 1;
541 char *buf = xcharalloc (bufsize);
542 quotearg_buffer (buf, bufsize, arg, argsize, o);
543 errno = e;
544 return buf;
545 }
546
547 /* A storage slot with size and pointer to a value. */
548 struct slotvec
549 {
550 size_t size;
551 char *val;
552 };
553
554 /* Preallocate a slot 0 buffer, so that the caller can always quote
555 one small component of a "memory exhausted" message in slot 0. */
556 static char slot0[256];
557 static unsigned int nslots = 1;
558 static struct slotvec slotvec0 = {sizeof slot0, slot0};
559 static struct slotvec *slotvec = &slotvec0;
560
561 void
562 quotearg_free (void)
563 {
564 struct slotvec *sv = slotvec;
565 unsigned int i;
566 for (i = 1; i < nslots; i++)
567 free (sv[i].val);
568 if (sv[0].val != slot0)
569 {
570 free (sv[0].val);
571 slotvec0.size = sizeof slot0;
572 slotvec0.val = slot0;
573 }
574 if (sv != &slotvec0)
575 {
576 free (sv);
577 slotvec = &slotvec0;
578 }
579 nslots = 1;
580 }
581
582 /* Use storage slot N to return a quoted version of argument ARG.
583 ARG is of size ARGSIZE, but if that is SIZE_MAX, ARG is a
584 null-terminated string.
585 OPTIONS specifies the quoting options.
586 The returned value points to static storage that can be
587 reused by the next call to this function with the same value of N.
588 N must be nonnegative. N is deliberately declared with type "int"
589 to allow for future extensions (using negative values). */
590 static char *
591 quotearg_n_options (int n, char const *arg, size_t argsize,
592 struct quoting_options const *options)
593 {
594 int e = errno;
595
596 unsigned int n0 = n;
597 struct slotvec *sv = slotvec;
598
599 if (n < 0)
600 abort ();
601
602 if (nslots <= n0)
603 {
604 /* FIXME: technically, the type of n1 should be `unsigned int',
605 but that evokes an unsuppressible warning from gcc-4.0.1 and
606 older. If gcc ever provides an option to suppress that warning,
607 revert to the original type, so that the test in xalloc_oversized
608 is once again performed only at compile time. */
609 size_t n1 = n0 + 1;
610 bool preallocated = (sv == &slotvec0);
611
612 if (xalloc_oversized (n1, sizeof *sv))
613 xalloc_die ();
614
615 slotvec = sv = xrealloc (preallocated ? NULL : sv, n1 * sizeof *sv);
616 if (preallocated)
617 *sv = slotvec0;
618 memset (sv + nslots, 0, (n1 - nslots) * sizeof *sv);
619 nslots = n1;
620 }
621
622 {
623 size_t size = sv[n].size;
624 char *val = sv[n].val;
625 size_t qsize = quotearg_buffer (val, size, arg, argsize, options);
626
627 if (size <= qsize)
628 {
629 sv[n].size = size = qsize + 1;
630 if (val != slot0)
631 free (val);
632 sv[n].val = val = xcharalloc (size);
633 quotearg_buffer (val, size, arg, argsize, options);
634 }
635
636 errno = e;
637 return val;
638 }
639 }
640
641 char *
642 quotearg_n (int n, char const *arg)
643 {
644 return quotearg_n_options (n, arg, SIZE_MAX, &default_quoting_options);
645 }
646
647 char *
648 quotearg (char const *arg)
649 {
650 return quotearg_n (0, arg);
651 }
652
653 /* Return quoting options for STYLE, with no extra quoting. */
654 static struct quoting_options
655 quoting_options_from_style (enum quoting_style style)
656 {
657 struct quoting_options o;
658 o.style = style;
659 memset (o.quote_these_too, 0, sizeof o.quote_these_too);
660 return o;
661 }
662
663 char *
664 quotearg_n_style (int n, enum quoting_style s, char const *arg)
665 {
666 struct quoting_options const o = quoting_options_from_style (s);
667 return quotearg_n_options (n, arg, SIZE_MAX, &o);
668 }
669
670 char *
671 quotearg_n_style_mem (int n, enum quoting_style s,
672 char const *arg, size_t argsize)
673 {
674 struct quoting_options const o = quoting_options_from_style (s);
675 return quotearg_n_options (n, arg, argsize, &o);
676 }
677
678 char *
679 quotearg_style (enum quoting_style s, char const *arg)
680 {
681 return quotearg_n_style (0, s, arg);
682 }
683
684 char *
685 quotearg_char (char const *arg, char ch)
686 {
687 struct quoting_options options;
688 options = default_quoting_options;
689 set_char_quoting (&options, ch, 1);
690 return quotearg_n_options (0, arg, SIZE_MAX, &options);
691 }
692
693 char *
694 quotearg_colon (char const *arg)
695 {
696 return quotearg_char (arg, ':');
697 }