pintos-os.org Git - pspp/blob - lib/quotearg.c

   1 /* quotearg.c - quote arguments for output
   2    Copyright (C) 1998, 1999, 2000 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 #include <sys/types.h>
  25 #include <quotearg.h>
  26 #include <xalloc.h>
  27
  28 #include <ctype.h>
  29 #if defined (STDC_HEADERS) || (!defined (isascii) && !defined (HAVE_ISASCII))
  30 # define ISASCII(c) 1
  31 #else
  32 # define ISASCII(c) isascii (c)
  33 #endif
  34 #define ISPRINT(c) (ISASCII (c) && isprint (c))
  35
  36 #if ENABLE_NLS
  37 # include <libintl.h>
  38 # define _(text) gettext (text)
  39 #else
  40 # define _(text) text
  41 #endif
  42
  43 #if HAVE_LIMITS_H
  44 # include <limits.h>
  45 #endif
  46 #ifndef CHAR_BIT
  47 # define CHAR_BIT 8
  48 #endif
  49 #ifndef UCHAR_MAX
  50 # define UCHAR_MAX ((unsigned char) -1)
  51 #endif
  52
  53 #if HAVE_STDLIB_H
  54 # include <stdlib.h>
  55 #endif
  56
  57 #if HAVE_STRING_H
  58 # include <string.h>
  59 #endif
  60
  61 #if HAVE_MBRTOWC && HAVE_WCHAR_H
  62 # include <wchar.h>
  63 #else
  64 # define iswprint(wc) 1
  65 # define mbrtowc(pwc, s, n, ps) 1
  66 # define mbsinit(ps) 1
  67 # define mbstate_t int
  68 #endif
  69
  70 #define INT_BITS (sizeof (int) * CHAR_BIT)
  71
  72 struct quoting_options
  73 {
  74   /* Basic quoting style.  */
  75   enum quoting_style style;
  76
  77   /* Quote the characters indicated by this bit vector even if the
  78      quoting style would not normally require them to be quoted.  */
  79   int quote_these_too[((UCHAR_MAX + 1) / INT_BITS
  80                        + ((UCHAR_MAX + 1) % INT_BITS != 0))];
  81 };
  82
  83 /* Names of quoting styles.  */
  84 char const *const quoting_style_args[] =
  85 {
  86   "literal",
  87   "shell",
  88   "shell-always",
  89   "c",
  90   "escape",
  91   "locale",
  92   0
  93 };
  94
  95 /* Correspondences to quoting style names.  */
  96 enum quoting_style const quoting_style_vals[] =
  97 {
  98   literal_quoting_style,
  99   shell_quoting_style,
 100   shell_always_quoting_style,
 101   c_quoting_style,
 102   escape_quoting_style,
 103   locale_quoting_style
 104 };
 105
 106 /* The default quoting options.  */
 107 static struct quoting_options default_quoting_options;
 108
 109 /* Allocate a new set of quoting options, with contents initially identical
 110    to O if O is not null, or to the default if O is null.
 111    It is the caller's responsibility to free the result.  */
 112 struct quoting_options *
 113 clone_quoting_options (struct quoting_options *o)
 114 {
 115   struct quoting_options *p
 116     = (struct quoting_options *) xmalloc (sizeof (struct quoting_options));
 117   *p = *(o ? o : &default_quoting_options);
 118   return p;
 119 }
 120
 121 /* Get the value of O's quoting style.  If O is null, use the default.  */
 122 enum quoting_style
 123 get_quoting_style (struct quoting_options *o)
 124 {
 125   return (o ? o : &default_quoting_options)->style;
 126 }
 127
 128 /* In O (or in the default if O is null),
 129    set the value of the quoting style to S.  */
 130 void
 131 set_quoting_style (struct quoting_options *o, enum quoting_style s)
 132 {
 133   (o ? o : &default_quoting_options)->style = s;
 134 }
 135
 136 /* In O (or in the default if O is null),
 137    set the value of the quoting options for character C to I.
 138    Return the old value.  Currently, the only values defined for I are
 139    0 (the default) and 1 (which means to quote the character even if
 140    it would not otherwise be quoted).  */
 141 int
 142 set_char_quoting (struct quoting_options *o, char c, int i)
 143 {
 144   unsigned char uc = c;
 145   int *p = (o ? o : &default_quoting_options)->quote_these_too + uc / INT_BITS;
 146   int shift = uc % INT_BITS;
 147   int r = (*p >> shift) & 1;
 148   *p ^= ((i & 1) ^ r) << shift;
 149   return r;
 150 }
 151
 152 /* Place into buffer BUFFER (of size BUFFERSIZE) a quoted version of
 153    argument ARG (of size ARGSIZE), using QUOTING_STYLE and the
 154    non-quoting-style part of O to control quoting.
 155    Terminate the output with a null character, and return the written
 156    size of the output, not counting the terminating null.
 157    If BUFFERSIZE is too small to store the output string, return the
 158    value that would have been returned had BUFFERSIZE been large enough.
 159    If ARGSIZE is -1, use the string length of the argument for ARGSIZE.
 160
 161    This function acts like quotearg_buffer (BUFFER, BUFFERSIZE, ARG,
 162    ARGSIZE, O), except it uses QUOTING_STYLE instead of the quoting
 163    style specified by O, and O may not be null.  */
 164
 165 static size_t
 166 quotearg_buffer_restyled (char *buffer, size_t buffersize,
 167                           char const *arg, size_t argsize,
 168                           enum quoting_style quoting_style,
 169                           struct quoting_options const *o)
 170 {
 171   size_t i;
 172   size_t len = 0;
 173   char const *quote_string = 0;
 174   size_t quote_string_len = 0;
 175   int backslash_escapes = 0;
 176
 177 #define STORE(c) \
 178     do \
 179       { \
 180         if (len < buffersize) \
 181           buffer[len] = (c); \
 182         len++; \
 183       } \
 184     while (0)
 185
 186   switch (quoting_style)
 187     {
 188     case c_quoting_style:
 189       STORE ('"');
 190       backslash_escapes = 1;
 191       quote_string = "\"";
 192       quote_string_len = 1;
 193       break;
 194
 195     case escape_quoting_style:
 196       backslash_escapes = 1;
 197       break;
 198
 199     case locale_quoting_style:
 200       for (quote_string = _("`"); *quote_string; quote_string++)
 201         STORE (*quote_string);
 202       backslash_escapes = 1;
 203       quote_string = _("'");
 204       quote_string_len = strlen (quote_string);
 205       break;
 206
 207     case shell_always_quoting_style:
 208       STORE ('\'');
 209       quote_string = "'";
 210       quote_string_len = 1;
 211       break;
 212
 213     default:
 214       break;
 215     }
 216
 217   for (i = 0;  ! (argsize == (size_t) -1 ? arg[i] == '\0' : i == argsize);  i++)
 218     {
 219       unsigned char c;
 220       unsigned char esc;
 221
 222       if (backslash_escapes
 223           && quote_string_len
 224           && i + quote_string_len <= argsize
 225           && memcmp (arg + i, quote_string, quote_string_len) == 0)
 226         STORE ('\\');
 227
 228       c = arg[i];
 229       switch (c)
 230         {
 231         case '?':
 232           switch (quoting_style)
 233             {
 234             case shell_quoting_style:
 235               goto use_shell_always_quoting_style;
 236
 237             case c_quoting_style:
 238               if (i + 2 < argsize && arg[i + 1] == '?')
 239                 switch (arg[i + 2])
 240                   {
 241                   case '!': case '\'':
 242                   case '(': case ')': case '-': case '/':
 243                   case '<': case '=': case '>':
 244                     /* Escape the second '?' in what would otherwise be
 245                        a trigraph.  */
 246                     i += 2;
 247                     c = arg[i + 2];
 248                     STORE ('?');
 249                     STORE ('\\');
 250                     STORE ('?');
 251                     break;
 252                   }
 253               break;
 254
 255             default:
 256               break;
 257             }
 258           break;
 259
 260 #if HAVE_C_BACKSLASH_A
 261         case '\a': esc = 'a'; goto c_escape;
 262 #endif
 263         case '\b': esc = 'b'; goto c_escape;
 264         case '\f': esc = 'f'; goto c_escape;
 265         case '\n': esc = 'n'; goto c_escape;
 266         case '\r': esc = 'r'; goto c_escape;
 267         case '\t': esc = 't'; goto c_escape;
 268         case '\v': esc = 'v'; goto c_escape;
 269         case '\\': esc = c; goto c_escape;
 270
 271         c_escape:
 272           if (backslash_escapes)
 273             {
 274               c = esc;
 275               goto store_escape;
 276             }
 277           if (quoting_style == shell_quoting_style)
 278             goto use_shell_always_quoting_style;
 279           break;
 280
 281         case '#': case '~':
 282           if (i != 0)
 283             break;
 284           /* Fall through.  */
 285         case ' ':
 286         case '!': /* special in bash */
 287         case '"': case '$': case '&':
 288         case '(': case ')': case '*': case ';':
 289         case '<': case '>': case '[':
 290         case '^': /* special in old /bin/sh, e.g. SunOS 4.1.4 */
 291         case '`': case '|':
 292           /* A shell special character.  In theory, '$' and '`' could
 293              be the first bytes of multibyte characters, which means
 294              we should check them with mbrtowc, but in practice this
 295              doesn't happen so it's not worth worrying about.  */
 296           if (quoting_style == shell_quoting_style)
 297             goto use_shell_always_quoting_style;
 298           break;
 299
 300         case '\'':
 301           switch (quoting_style)
 302             {
 303             case shell_quoting_style:
 304               goto use_shell_always_quoting_style;
 305
 306             case shell_always_quoting_style:
 307               STORE ('\'');
 308               STORE ('\\');
 309               STORE ('\'');
 310               break;
 311
 312             default:
 313               break;
 314             }
 315           break;
 316
 317         case '%': case '+': case ',': case '-': case '.': case '/':
 318         case '0': case '1': case '2': case '3': case '4': case '5':
 319         case '6': case '7': case '8': case '9': case ':': case '=':
 320         case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
 321         case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
 322         case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
 323         case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
 324         case 'Y': case 'Z': case ']': case '_': case 'a': case 'b':
 325         case 'c': case 'd': case 'e': case 'f': case 'g': case 'h':
 326         case 'i': case 'j': case 'k': case 'l': case 'm': case 'n':
 327         case 'o': case 'p': case 'q': case 'r': case 's': case 't':
 328         case 'u': case 'v': case 'w': case 'x': case 'y': case 'z':
 329         case '{': case '}':
 330           /* These characters don't cause problems, no matter what the
 331              quoting style is.  They cannot start multibyte sequences.  */
 332           break;
 333
 334         default:
 335           /* If we have a multibyte sequence, copy it until we reach
 336              its end, find an error, or come back to the initial shift
 337              state.  For C-like styles, if the sequence has
 338              unprintable characters, escape the whole sequence, since
 339              we can't easily escape single characters within it.  */
 340           {
 341             /* Length of multibyte sequence found so far.  */
 342             size_t m = 0;
 343
 344             int printable = 1;
 345             mbstate_t mbstate;
 346             memset (&mbstate, 0, sizeof mbstate);
 347
 348             if (argsize == (size_t) -1)
 349               argsize = strlen (arg);
 350
 351             do
 352               {
 353                 wchar_t w;
 354                 size_t bytes = mbrtowc (&w, &arg[i + m],
 355                                         argsize - (i + m), &mbstate);
 356                 if (bytes == 0)
 357                   break;
 358                 else if (bytes == (size_t) -1)
 359                   {
 360                     printable = 0;
 361                     break;
 362                   }
 363                 else if (bytes == (size_t) -2)
 364                   {
 365                     printable = 0;
 366                     while (i + m < argsize && arg[i + m])
 367                       m++;
 368                     break;
 369                   }
 370                 else
 371                   {
 372                     if (! iswprint (w))
 373                       printable = 0;
 374                     m += bytes;
 375                   }
 376               }
 377             while (! mbsinit (&mbstate));
 378
 379             if (m <= 1)
 380               {
 381                 /* Escape a unibyte character like a multibyte
 382                    sequence if using backslash escapes, and if the
 383                    character is not printable.  */
 384                 m = backslash_escapes && ! ISPRINT (c);
 385                 printable = 0;
 386               }
 387
 388             if (m)
 389               {
 390                 /* Output a multibyte sequence, or an escaped
 391                    unprintable unibyte character.  */
 392                 size_t imax = i + m - 1;
 393
 394                 for (;;)
 395                   {
 396                     if (backslash_escapes && ! printable)
 397                       {
 398                         STORE ('\\');
 399                         STORE ('0' + (c >> 6));
 400                         STORE ('0' + ((c >> 3) & 7));
 401                         c = '0' + (c & 7);
 402                       }
 403                     if (i == imax)
 404                       break;
 405                     STORE (c);
 406                     c = arg[++i];
 407                   }
 408
 409                 goto store_c;
 410               }
 411           }
 412         }
 413
 414       if (! (backslash_escapes
 415              && o->quote_these_too[c / INT_BITS] & (1 << (c % INT_BITS))))
 416         goto store_c;
 417
 418     store_escape:
 419       STORE ('\\');
 420
 421     store_c:
 422       STORE (c);
 423     }
 424
 425   if (quote_string)
 426     for (; *quote_string; quote_string++)
 427       STORE (*quote_string);
 428
 429   if (len < buffersize)
 430     buffer[len] = '\0';
 431   return len;
 432
 433  use_shell_always_quoting_style:
 434   return quotearg_buffer_restyled (buffer, buffersize, arg, argsize,
 435                                    shell_always_quoting_style, o);
 436 }
 437
 438 /* Place into buffer BUFFER (of size BUFFERSIZE) a quoted version of
 439    argument ARG (of size ARGSIZE), using O to control quoting.
 440    If O is null, use the default.
 441    Terminate the output with a null character, and return the written
 442    size of the output, not counting the terminating null.
 443    If BUFFERSIZE is too small to store the output string, return the
 444    value that would have been returned had BUFFERSIZE been large enough.
 445    If ARGSIZE is -1, use the string length of the argument for ARGSIZE.  */
 446 size_t
 447 quotearg_buffer (char *buffer, size_t buffersize,
 448                  char const *arg, size_t argsize,
 449                  struct quoting_options const *o)
 450 {
 451   struct quoting_options const *p = o ? o : &default_quoting_options;
 452   return quotearg_buffer_restyled (buffer, buffersize, arg, argsize,
 453                                    p->style, p);
 454 }
 455
 456 /* Use storage slot N to return a quoted version of the string ARG.
 457    OPTIONS specifies the quoting options.
 458    The returned value points to static storage that can be
 459    reused by the next call to this function with the same value of N.
 460    N must be nonnegative.  N is deliberately declared with type `int'
 461    to allow for future extensions (using negative values).  */
 462 static char *
 463 quotearg_n_options (int n, char const *arg,
 464                     struct quoting_options const *options)
 465 {
 466   static unsigned int nslots;
 467   static struct slotvec
 468     {
 469       size_t size;
 470       char *val;
 471     } *slotvec;
 472
 473   if (nslots <= n)
 474     {
 475       int n1 = n + 1;
 476       size_t s = n1 * sizeof (struct slotvec);
 477       if (! (0 < n1 && n1 == s / sizeof (struct slotvec)))
 478         abort ();
 479       slotvec = (struct slotvec *) xrealloc (slotvec, s);
 480       memset (slotvec + nslots, 0, (n1 - nslots) * sizeof (struct slotvec));
 481       nslots = n;
 482     }
 483
 484   {
 485     size_t size = slotvec[n].size;
 486     char *val = slotvec[n].val;
 487     size_t qsize = quotearg_buffer (val, size, arg, (size_t) -1, options);
 488
 489     if (size <= qsize)
 490       {
 491         slotvec[n].size = size = qsize + 1;
 492         slotvec[n].val = val = xrealloc (val, size);
 493         quotearg_buffer (val, size, arg, (size_t) -1, options);
 494       }
 495
 496     return val;
 497   }
 498 }
 499
 500 char *
 501 quotearg_n (unsigned int n, char const *arg)
 502 {
 503   return quotearg_n_options (n, arg, &default_quoting_options);
 504 }
 505
 506 char *
 507 quotearg (char const *arg)
 508 {
 509   return quotearg_n (0, arg);
 510 }
 511
 512 char *
 513 quotearg_n_style (unsigned int n, enum quoting_style s, char const *arg)
 514 {
 515   struct quoting_options o;
 516   o.style = s;
 517   memset (o.quote_these_too, 0, sizeof o.quote_these_too);
 518   return quotearg_n_options (n, arg, &o);
 519 }
 520
 521 char *
 522 quotearg_style (enum quoting_style s, char const *arg)
 523 {
 524   return quotearg_n_style (0, s, arg);
 525 }
 526
 527 char *
 528 quotearg_char (char const *arg, char ch)
 529 {
 530   struct quoting_options options;
 531   options = default_quoting_options;
 532   set_char_quoting (&options, ch, 1);
 533   return quotearg_n_options (0, arg, &options);
 534 }
 535
 536 char *
 537 quotearg_colon (char const *arg)
 538 {
 539   return quotearg_char (arg, ':');
 540 }