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