lib/quotearg.c

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