contrib/diffutils/lib/quotearg.c

   1 /* quotearg.c - quote arguments for output
   2
   3    Copyright (C) 1998-2002, 2004-2013 Free Software Foundation, Inc.
   4
   5    This program is free software: you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 3 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  17
  18 /* Written by Paul Eggert <eggert@twinsun.com> */
  19
  20 /* Without this pragma, gcc 4.7.0 20111124 mistakenly suggests that
  21    the quoting_options_from_style function might be candidate for
  22    attribute 'pure'  */
  23 #if (__GNUC__ == 4 && 6 <= __GNUC_MINOR__) || 4 < __GNUC__
  24 # pragma GCC diagnostic ignored "-Wsuggest-attribute=pure"
  25 #endif
  26
  27 #include <config.h>
  28
  29 #include "quotearg.h"
  30 #include "quote.h"
  31
  32 #include "xalloc.h"
  33 #include "c-strcaseeq.h"
  34 #include "localcharset.h"
  35
  36 #include <ctype.h>
  37 #include <errno.h>
  38 #include <limits.h>
  39 #include <stdbool.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42 #include <wchar.h>
  43 #include <wctype.h>
  44
  45 #include "gettext.h"
  46 #define _(msgid) gettext (msgid)
  47 #define N_(msgid) msgid
  48
  49 #ifndef SIZE_MAX
  50 # define SIZE_MAX ((size_t) -1)
  51 #endif
  52
  53 #define INT_BITS (sizeof (int) * CHAR_BIT)
  54
  55 struct quoting_options
  56 {
  57   /* Basic quoting style.  */
  58   enum quoting_style style;
  59
  60   /* Additional flags.  Bitwise combination of enum quoting_flags.  */
  61   int flags;
  62
  63   /* Quote the characters indicated by this bit vector even if the
  64      quoting style would not normally require them to be quoted.  */
  65   unsigned int quote_these_too[(UCHAR_MAX / INT_BITS) + 1];
  66
  67   /* The left quote for custom_quoting_style.  */
  68   char const *left_quote;
  69
  70   /* The right quote for custom_quoting_style.  */
  71   char const *right_quote;
  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   "c-maybe",
  82   "escape",
  83   "locale",
  84   "clocale",
  85   0
  86 };
  87
  88 /* Correspondences to quoting style names.  */
  89 enum quoting_style const quoting_style_vals[] =
  90 {
  91   literal_quoting_style,
  92   shell_quoting_style,
  93   shell_always_quoting_style,
  94   c_quoting_style,
  95   c_maybe_quoting_style,
  96   escape_quoting_style,
  97   locale_quoting_style,
  98   clocale_quoting_style
  99 };
 100
 101 /* The default quoting options.  */
 102 static struct quoting_options default_quoting_options;
 103
 104 /* Allocate a new set of quoting options, with contents initially identical
 105    to O if O is not null, or to the default if O is null.
 106    It is the caller's responsibility to free the result.  */
 107 struct quoting_options *
 108 clone_quoting_options (struct quoting_options *o)
 109 {
 110   int e = errno;
 111   struct quoting_options *p = xmemdup (o ? o : &default_quoting_options,
 112                                        sizeof *o);
 113   errno = e;
 114   return p;
 115 }
 116
 117 /* Get the value of O's quoting style.  If O is null, use the default.  */
 118 enum quoting_style
 119 get_quoting_style (struct quoting_options *o)
 120 {
 121   return (o ? o : &default_quoting_options)->style;
 122 }
 123
 124 /* In O (or in the default if O is null),
 125    set the value of the quoting style to S.  */
 126 void
 127 set_quoting_style (struct quoting_options *o, enum quoting_style s)
 128 {
 129   (o ? o : &default_quoting_options)->style = s;
 130 }
 131
 132 /* In O (or in the default if O is null),
 133    set the value of the quoting options for character C to I.
 134    Return the old value.  Currently, the only values defined for I are
 135    0 (the default) and 1 (which means to quote the character even if
 136    it would not otherwise be quoted).  */
 137 int
 138 set_char_quoting (struct quoting_options *o, char c, int i)
 139 {
 140   unsigned char uc = c;
 141   unsigned int *p =
 142     (o ? o : &default_quoting_options)->quote_these_too + uc / INT_BITS;
 143   int shift = uc % INT_BITS;
 144   int r = (*p >> shift) & 1;
 145   *p ^= ((i & 1) ^ r) << shift;
 146   return r;
 147 }
 148
 149 /* In O (or in the default if O is null),
 150    set the value of the quoting options flag to I, which can be a
 151    bitwise combination of enum quoting_flags, or 0 for default
 152    behavior.  Return the old value.  */
 153 int
 154 set_quoting_flags (struct quoting_options *o, int i)
 155 {
 156   int r;
 157   if (!o)
 158     o = &default_quoting_options;
 159   r = o->flags;
 160   o->flags = i;
 161   return r;
 162 }
 163
 164 void
 165 set_custom_quoting (struct quoting_options *o,
 166                     char const *left_quote, char const *right_quote)
 167 {
 168   if (!o)
 169     o = &default_quoting_options;
 170   o->style = custom_quoting_style;
 171   if (!left_quote || !right_quote)
 172     abort ();
 173   o->left_quote = left_quote;
 174   o->right_quote = right_quote;
 175 }
 176
 177 /* Return quoting options for STYLE, with no extra quoting.  */
 178 static struct quoting_options /* NOT PURE!! */
 179 quoting_options_from_style (enum quoting_style style)
 180 {
 181   struct quoting_options o = { 0, 0, { 0 }, NULL, NULL };
 182   if (style == custom_quoting_style)
 183     abort ();
 184   o.style = style;
 185   return o;
 186 }
 187
 188 /* MSGID approximates a quotation mark.  Return its translation if it
 189    has one; otherwise, return either it or "\"", depending on S.
 190
 191    S is either clocale_quoting_style or locale_quoting_style.  */
 192 static char const *
 193 gettext_quote (char const *msgid, enum quoting_style s)
 194 {
 195   char const *translation = _(msgid);
 196   char const *locale_code;
 197
 198   if (translation != msgid)
 199     return translation;
 200
 201   /* For UTF-8 and GB-18030, use single quotes U+2018 and U+2019.
 202      Here is a list of other locales that include U+2018 and U+2019:
 203
 204         ISO-8859-7   0xA1                 KOI8-T       0x91
 205         CP869        0x8B                 CP874        0x91
 206         CP932        0x81 0x65            CP936        0xA1 0xAE
 207         CP949        0xA1 0xAE            CP950        0xA1 0xA5
 208         CP1250       0x91                 CP1251       0x91
 209         CP1252       0x91                 CP1253       0x91
 210         CP1254       0x91                 CP1255       0x91
 211         CP1256       0x91                 CP1257       0x91
 212         EUC-JP       0xA1 0xC6            EUC-KR       0xA1 0xAE
 213         EUC-TW       0xA1 0xE4            BIG5         0xA1 0xA5
 214         BIG5-HKSCS   0xA1 0xA5            EUC-CN       0xA1 0xAE
 215         GBK          0xA1 0xAE            Georgian-PS  0x91
 216         PT154        0x91
 217
 218      None of these is still in wide use; using iconv is overkill.  */
 219   locale_code = locale_charset ();
 220   if (STRCASEEQ (locale_code, "UTF-8", 'U','T','F','-','8',0,0,0,0))
 221     return msgid[0] == '`' ? "\xe2\x80\x98": "\xe2\x80\x99";
 222   if (STRCASEEQ (locale_code, "GB18030", 'G','B','1','8','0','3','0',0,0))
 223     return msgid[0] == '`' ? "\xa1\ae": "\xa1\xaf";
 224
 225   return (s == clocale_quoting_style ? "\"" : "'");
 226 }
 227
 228 /* Place into buffer BUFFER (of size BUFFERSIZE) a quoted version of
 229    argument ARG (of size ARGSIZE), using QUOTING_STYLE, FLAGS, and
 230    QUOTE_THESE_TOO to control quoting.
 231    Terminate the output with a null character, and return the written
 232    size of the output, not counting the terminating null.
 233    If BUFFERSIZE is too small to store the output string, return the
 234    value that would have been returned had BUFFERSIZE been large enough.
 235    If ARGSIZE is SIZE_MAX, use the string length of the argument for ARGSIZE.
 236
 237    This function acts like quotearg_buffer (BUFFER, BUFFERSIZE, ARG,
 238    ARGSIZE, O), except it breaks O into its component pieces and is
 239    not careful about errno.  */
 240
 241 static size_t
 242 quotearg_buffer_restyled (char *buffer, size_t buffersize,
 243                           char const *arg, size_t argsize,
 244                           enum quoting_style quoting_style, int flags,
 245                           unsigned int const *quote_these_too,
 246                           char const *left_quote,
 247                           char const *right_quote)
 248 {
 249   size_t i;
 250   size_t len = 0;
 251   char const *quote_string = 0;
 252   size_t quote_string_len = 0;
 253   bool backslash_escapes = false;
 254   bool unibyte_locale = MB_CUR_MAX == 1;
 255   bool elide_outer_quotes = (flags & QA_ELIDE_OUTER_QUOTES) != 0;
 256
 257 #define STORE(c) \
 258     do \
 259       { \
 260         if (len < buffersize) \
 261           buffer[len] = (c); \
 262         len++; \
 263       } \
 264     while (0)
 265
 266   switch (quoting_style)
 267     {
 268     case c_maybe_quoting_style:
 269       quoting_style = c_quoting_style;
 270       elide_outer_quotes = true;
 271       /* Fall through.  */
 272     case c_quoting_style:
 273       if (!elide_outer_quotes)
 274         STORE ('"');
 275       backslash_escapes = true;
 276       quote_string = "\"";
 277       quote_string_len = 1;
 278       break;
 279
 280     case escape_quoting_style:
 281       backslash_escapes = true;
 282       elide_outer_quotes = false;
 283       break;
 284
 285     case locale_quoting_style:
 286     case clocale_quoting_style:
 287     case custom_quoting_style:
 288       {
 289         if (quoting_style != custom_quoting_style)
 290           {
 291             /* TRANSLATORS:
 292                Get translations for open and closing quotation marks.
 293                The message catalog should translate "`" to a left
 294                quotation mark suitable for the locale, and similarly for
 295                "'".  For example, a French Unicode local should translate
 296                these to U+00AB (LEFT-POINTING DOUBLE ANGLE
 297                QUOTATION MARK), and U+00BB (RIGHT-POINTING DOUBLE ANGLE
 298                QUOTATION MARK), respectively.
 299
 300                If the catalog has no translation, we will try to
 301                use Unicode U+2018 (LEFT SINGLE QUOTATION MARK) and
 302                Unicode U+2019 (RIGHT SINGLE QUOTATION MARK).  If the
 303                current locale is not Unicode, locale_quoting_style
 304                will quote 'like this', and clocale_quoting_style will
 305                quote "like this".  You should always include translations
 306                for "`" and "'" even if U+2018 and U+2019 are appropriate
 307                for your locale.
 308
 309                If you don't know what to put here, please see
 310                <http://en.wikipedia.org/wiki/Quotation_marks_in_other_languages>
 311                and use glyphs suitable for your language.  */
 312             left_quote = gettext_quote (N_("`"), quoting_style);
 313             right_quote = gettext_quote (N_("'"), quoting_style);
 314           }
 315         if (!elide_outer_quotes)
 316           for (quote_string = left_quote; *quote_string; quote_string++)
 317             STORE (*quote_string);
 318         backslash_escapes = true;
 319         quote_string = right_quote;
 320         quote_string_len = strlen (quote_string);
 321       }
 322       break;
 323
 324     case shell_quoting_style:
 325       quoting_style = shell_always_quoting_style;
 326       elide_outer_quotes = true;
 327       /* Fall through.  */
 328     case shell_always_quoting_style:
 329       if (!elide_outer_quotes)
 330         STORE ('\'');
 331       quote_string = "'";
 332       quote_string_len = 1;
 333       break;
 334
 335     case literal_quoting_style:
 336       elide_outer_quotes = false;
 337       break;
 338
 339     default:
 340       abort ();
 341     }
 342
 343   for (i = 0;  ! (argsize == SIZE_MAX ? arg[i] == '\0' : i == argsize);  i++)
 344     {
 345       unsigned char c;
 346       unsigned char esc;
 347       bool is_right_quote = false;
 348
 349       if (backslash_escapes
 350           && quote_string_len
 351           && i + quote_string_len <= argsize
 352           && memcmp (arg + i, quote_string, quote_string_len) == 0)
 353         {
 354           if (elide_outer_quotes)
 355             goto force_outer_quoting_style;
 356           is_right_quote = true;
 357         }
 358
 359       c = arg[i];
 360       switch (c)
 361         {
 362         case '\0':
 363           if (backslash_escapes)
 364             {
 365               if (elide_outer_quotes)
 366                 goto force_outer_quoting_style;
 367               STORE ('\\');
 368               /* If quote_string were to begin with digits, we'd need to
 369                  test for the end of the arg as well.  However, it's
 370                  hard to imagine any locale that would use digits in
 371                  quotes, and set_custom_quoting is documented not to
 372                  accept them.  */
 373               if (i + 1 < argsize && '0' <= arg[i + 1] && arg[i + 1] <= '9')
 374                 {
 375                   STORE ('0');
 376                   STORE ('0');
 377                 }
 378               c = '0';
 379               /* We don't have to worry that this last '0' will be
 380                  backslash-escaped because, again, quote_string should
 381                  not start with it and because quote_these_too is
 382                  documented as not accepting it.  */
 383             }
 384           else if (flags & QA_ELIDE_NULL_BYTES)
 385             continue;
 386           break;
 387
 388         case '?':
 389           switch (quoting_style)
 390             {
 391             case shell_always_quoting_style:
 392               if (elide_outer_quotes)
 393                 goto force_outer_quoting_style;
 394               break;
 395
 396             case c_quoting_style:
 397               if ((flags & QA_SPLIT_TRIGRAPHS)
 398                   && i + 2 < argsize && arg[i + 1] == '?')
 399                 switch (arg[i + 2])
 400                   {
 401                   case '!': case '\'':
 402                   case '(': case ')': case '-': case '/':
 403                   case '<': case '=': case '>':
 404                     /* Escape the second '?' in what would otherwise be
 405                        a trigraph.  */
 406                     if (elide_outer_quotes)
 407                       goto force_outer_quoting_style;
 408                     c = arg[i + 2];
 409                     i += 2;
 410                     STORE ('?');
 411                     STORE ('"');
 412                     STORE ('"');
 413                     STORE ('?');
 414                     break;
 415
 416                   default:
 417                     break;
 418                   }
 419               break;
 420
 421             default:
 422               break;
 423             }
 424           break;
 425
 426         case '\a': esc = 'a'; goto c_escape;
 427         case '\b': esc = 'b'; goto c_escape;
 428         case '\f': esc = 'f'; goto c_escape;
 429         case '\n': esc = 'n'; goto c_and_shell_escape;
 430         case '\r': esc = 'r'; goto c_and_shell_escape;
 431         case '\t': esc = 't'; goto c_and_shell_escape;
 432         case '\v': esc = 'v'; goto c_escape;
 433         case '\\': esc = c;
 434           /* No need to escape the escape if we are trying to elide
 435              outer quotes and nothing else is problematic.  */
 436           if (backslash_escapes && elide_outer_quotes && quote_string_len)
 437             goto store_c;
 438
 439         c_and_shell_escape:
 440           if (quoting_style == shell_always_quoting_style
 441               && elide_outer_quotes)
 442             goto force_outer_quoting_style;
 443           /* Fall through.  */
 444         c_escape:
 445           if (backslash_escapes)
 446             {
 447               c = esc;
 448               goto store_escape;
 449             }
 450           break;
 451
 452         case '{': case '}': /* sometimes special if isolated */
 453           if (! (argsize == SIZE_MAX ? arg[1] == '\0' : argsize == 1))
 454             break;
 455           /* Fall through.  */
 456         case '#': case '~':
 457           if (i != 0)
 458             break;
 459           /* Fall through.  */
 460         case ' ':
 461         case '!': /* special in bash */
 462         case '"': case '$': case '&':
 463         case '(': case ')': case '*': case ';':
 464         case '<':
 465         case '=': /* sometimes special in 0th or (with "set -k") later args */
 466         case '>': case '[':
 467         case '^': /* special in old /bin/sh, e.g. SunOS 4.1.4 */
 468         case '`': case '|':
 469           /* A shell special character.  In theory, '$' and '`' could
 470              be the first bytes of multibyte characters, which means
 471              we should check them with mbrtowc, but in practice this
 472              doesn't happen so it's not worth worrying about.  */
 473           if (quoting_style == shell_always_quoting_style
 474               && elide_outer_quotes)
 475             goto force_outer_quoting_style;
 476           break;
 477
 478         case '\'':
 479           if (quoting_style == shell_always_quoting_style)
 480             {
 481               if (elide_outer_quotes)
 482                 goto force_outer_quoting_style;
 483               STORE ('\'');
 484               STORE ('\\');
 485               STORE ('\'');
 486             }
 487           break;
 488
 489         case '%': case '+': case ',': case '-': case '.': case '/':
 490         case '0': case '1': case '2': case '3': case '4': case '5':
 491         case '6': case '7': case '8': case '9': case ':':
 492         case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
 493         case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
 494         case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
 495         case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
 496         case 'Y': case 'Z': case ']': case '_': case 'a': case 'b':
 497         case 'c': case 'd': case 'e': case 'f': case 'g': case 'h':
 498         case 'i': case 'j': case 'k': case 'l': case 'm': case 'n':
 499         case 'o': case 'p': case 'q': case 'r': case 's': case 't':
 500         case 'u': case 'v': case 'w': case 'x': case 'y': case 'z':
 501           /* These characters don't cause problems, no matter what the
 502              quoting style is.  They cannot start multibyte sequences.
 503              A digit or a special letter would cause trouble if it
 504              appeared at the beginning of quote_string because we'd then
 505              escape by prepending a backslash.  However, it's hard to
 506              imagine any locale that would use digits or letters as
 507              quotes, and set_custom_quoting is documented not to accept
 508              them.  Also, a digit or a special letter would cause
 509              trouble if it appeared in quote_these_too, but that's also
 510              documented as not accepting them.  */
 511           break;
 512
 513         default:
 514           /* If we have a multibyte sequence, copy it until we reach
 515              its end, find an error, or come back to the initial shift
 516              state.  For C-like styles, if the sequence has
 517              unprintable characters, escape the whole sequence, since
 518              we can't easily escape single characters within it.  */
 519           {
 520             /* Length of multibyte sequence found so far.  */
 521             size_t m;
 522
 523             bool printable;
 524
 525             if (unibyte_locale)
 526               {
 527                 m = 1;
 528                 printable = isprint (c) != 0;
 529               }
 530             else
 531               {
 532                 mbstate_t mbstate;
 533                 memset (&mbstate, 0, sizeof mbstate);
 534
 535                 m = 0;
 536                 printable = true;
 537                 if (argsize == SIZE_MAX)
 538                   argsize = strlen (arg);
 539
 540                 do
 541                   {
 542                     wchar_t w;
 543                     size_t bytes = mbrtowc (&w, &arg[i + m],
 544                                             argsize - (i + m), &mbstate);
 545                     if (bytes == 0)
 546                       break;
 547                     else if (bytes == (size_t) -1)
 548                       {
 549                         printable = false;
 550                         break;
 551                       }
 552                     else if (bytes == (size_t) -2)
 553                       {
 554                         printable = false;
 555                         while (i + m < argsize && arg[i + m])
 556                           m++;
 557                         break;
 558                       }
 559                     else
 560                       {
 561                         /* Work around a bug with older shells that "see" a '\'
 562                            that is really the 2nd byte of a multibyte character.
 563                            In practice the problem is limited to ASCII
 564                            chars >= '@' that are shell special chars.  */
 565                         if ('[' == 0x5b && elide_outer_quotes
 566                             && quoting_style == shell_always_quoting_style)
 567                           {
 568                             size_t j;
 569                             for (j = 1; j < bytes; j++)
 570                               switch (arg[i + m + j])
 571                                 {
 572                                 case '[': case '\\': case '^':
 573                                 case '`': case '|':
 574                                   goto force_outer_quoting_style;
 575
 576                                 default:
 577                                   break;
 578                                 }
 579                           }
 580
 581                         if (! iswprint (w))
 582                           printable = false;
 583                         m += bytes;
 584                       }
 585                   }
 586                 while (! mbsinit (&mbstate));
 587               }
 588
 589             if (1 < m || (backslash_escapes && ! printable))
 590               {
 591                 /* Output a multibyte sequence, or an escaped
 592                    unprintable unibyte character.  */
 593                 size_t ilim = i + m;
 594
 595                 for (;;)
 596                   {
 597                     if (backslash_escapes && ! printable)
 598                       {
 599                         if (elide_outer_quotes)
 600                           goto force_outer_quoting_style;
 601                         STORE ('\\');
 602                         STORE ('0' + (c >> 6));
 603                         STORE ('0' + ((c >> 3) & 7));
 604                         c = '0' + (c & 7);
 605                       }
 606                     else if (is_right_quote)
 607                       {
 608                         STORE ('\\');
 609                         is_right_quote = false;
 610                       }
 611                     if (ilim <= i + 1)
 612                       break;
 613                     STORE (c);
 614                     c = arg[++i];
 615                   }
 616
 617                 goto store_c;
 618               }
 619           }
 620         }
 621
 622       if (! ((backslash_escapes || elide_outer_quotes)
 623              && quote_these_too
 624              && quote_these_too[c / INT_BITS] & (1 << (c % INT_BITS)))
 625           && !is_right_quote)
 626         goto store_c;
 627
 628     store_escape:
 629       if (elide_outer_quotes)
 630         goto force_outer_quoting_style;
 631       STORE ('\\');
 632
 633     store_c:
 634       STORE (c);
 635     }
 636
 637   if (len == 0 && quoting_style == shell_always_quoting_style
 638       && elide_outer_quotes)
 639     goto force_outer_quoting_style;
 640
 641   if (quote_string && !elide_outer_quotes)
 642     for (; *quote_string; quote_string++)
 643       STORE (*quote_string);
 644
 645   if (len < buffersize)
 646     buffer[len] = '\0';
 647   return len;
 648
 649  force_outer_quoting_style:
 650   /* Don't reuse quote_these_too, since the addition of outer quotes
 651      sufficiently quotes the specified characters.  */
 652   return quotearg_buffer_restyled (buffer, buffersize, arg, argsize,
 653                                    quoting_style,
 654                                    flags & ~QA_ELIDE_OUTER_QUOTES, NULL,
 655                                    left_quote, right_quote);
 656 }
 657
 658 /* Place into buffer BUFFER (of size BUFFERSIZE) a quoted version of
 659    argument ARG (of size ARGSIZE), using O to control quoting.
 660    If O is null, use the default.
 661    Terminate the output with a null character, and return the written
 662    size of the output, not counting the terminating null.
 663    If BUFFERSIZE is too small to store the output string, return the
 664    value that would have been returned had BUFFERSIZE been large enough.
 665    If ARGSIZE is SIZE_MAX, use the string length of the argument for
 666    ARGSIZE.  */
 667 size_t
 668 quotearg_buffer (char *buffer, size_t buffersize,
 669                  char const *arg, size_t argsize,
 670                  struct quoting_options const *o)
 671 {
 672   struct quoting_options const *p = o ? o : &default_quoting_options;
 673   int e = errno;
 674   size_t r = quotearg_buffer_restyled (buffer, buffersize, arg, argsize,
 675                                        p->style, p->flags, p->quote_these_too,
 676                                        p->left_quote, p->right_quote);
 677   errno = e;
 678   return r;
 679 }
 680
 681 /* Equivalent to quotearg_alloc (ARG, ARGSIZE, NULL, O).  */
 682 char *
 683 quotearg_alloc (char const *arg, size_t argsize,
 684                 struct quoting_options const *o)
 685 {
 686   return quotearg_alloc_mem (arg, argsize, NULL, o);
 687 }
 688
 689 /* Like quotearg_buffer (..., ARG, ARGSIZE, O), except return newly
 690    allocated storage containing the quoted string, and store the
 691    resulting size into *SIZE, if non-NULL.  The result can contain
 692    embedded null bytes only if ARGSIZE is not SIZE_MAX, SIZE is not
 693    NULL, and set_quoting_flags has not set the null byte elision
 694    flag.  */
 695 char *
 696 quotearg_alloc_mem (char const *arg, size_t argsize, size_t *size,
 697                     struct quoting_options const *o)
 698 {
 699   struct quoting_options const *p = o ? o : &default_quoting_options;
 700   int e = errno;
 701   /* Elide embedded null bytes if we can't return a size.  */
 702   int flags = p->flags | (size ? 0 : QA_ELIDE_NULL_BYTES);
 703   size_t bufsize = quotearg_buffer_restyled (0, 0, arg, argsize, p->style,
 704                                              flags, p->quote_these_too,
 705                                              p->left_quote,
 706                                              p->right_quote) + 1;
 707   char *buf = xcharalloc (bufsize);
 708   quotearg_buffer_restyled (buf, bufsize, arg, argsize, p->style, flags,
 709                             p->quote_these_too,
 710                             p->left_quote, p->right_quote);
 711   errno = e;
 712   if (size)
 713     *size = bufsize - 1;
 714   return buf;
 715 }
 716
 717 /* A storage slot with size and pointer to a value.  */
 718 struct slotvec
 719 {
 720   size_t size;
 721   char *val;
 722 };
 723
 724 /* Preallocate a slot 0 buffer, so that the caller can always quote
 725    one small component of a "memory exhausted" message in slot 0.  */
 726 static char slot0[256];
 727 static unsigned int nslots = 1;
 728 static struct slotvec slotvec0 = {sizeof slot0, slot0};
 729 static struct slotvec *slotvec = &slotvec0;
 730
 731 void
 732 quotearg_free (void)
 733 {
 734   struct slotvec *sv = slotvec;
 735   unsigned int i;
 736   for (i = 1; i < nslots; i++)
 737     free (sv[i].val);
 738   if (sv[0].val != slot0)
 739     {
 740       free (sv[0].val);
 741       slotvec0.size = sizeof slot0;
 742       slotvec0.val = slot0;
 743     }
 744   if (sv != &slotvec0)
 745     {
 746       free (sv);
 747       slotvec = &slotvec0;
 748     }
 749   nslots = 1;
 750 }
 751
 752 /* Use storage slot N to return a quoted version of argument ARG.
 753    ARG is of size ARGSIZE, but if that is SIZE_MAX, ARG is a
 754    null-terminated string.
 755    OPTIONS specifies the quoting options.
 756    The returned value points to static storage that can be
 757    reused by the next call to this function with the same value of N.
 758    N must be nonnegative.  N is deliberately declared with type "int"
 759    to allow for future extensions (using negative values).  */
 760 static char *
 761 quotearg_n_options (int n, char const *arg, size_t argsize,
 762                     struct quoting_options const *options)
 763 {
 764   int e = errno;
 765
 766   unsigned int n0 = n;
 767   struct slotvec *sv = slotvec;
 768
 769   if (n < 0)
 770     abort ();
 771
 772   if (nslots <= n0)
 773     {
 774       /* FIXME: technically, the type of n1 should be 'unsigned int',
 775          but that evokes an unsuppressible warning from gcc-4.0.1 and
 776          older.  If gcc ever provides an option to suppress that warning,
 777          revert to the original type, so that the test in xalloc_oversized
 778          is once again performed only at compile time.  */
 779       size_t n1 = n0 + 1;
 780       bool preallocated = (sv == &slotvec0);
 781
 782       if (xalloc_oversized (n1, sizeof *sv))
 783         xalloc_die ();
 784
 785       slotvec = sv = xrealloc (preallocated ? NULL : sv, n1 * sizeof *sv);
 786       if (preallocated)
 787         *sv = slotvec0;
 788       memset (sv + nslots, 0, (n1 - nslots) * sizeof *sv);
 789       nslots = n1;
 790     }
 791
 792   {
 793     size_t size = sv[n].size;
 794     char *val = sv[n].val;
 795     /* Elide embedded null bytes since we don't return a size.  */
 796     int flags = options->flags | QA_ELIDE_NULL_BYTES;
 797     size_t qsize = quotearg_buffer_restyled (val, size, arg, argsize,
 798                                              options->style, flags,
 799                                              options->quote_these_too,
 800                                              options->left_quote,
 801                                              options->right_quote);
 802
 803     if (size <= qsize)
 804       {
 805         sv[n].size = size = qsize + 1;
 806         if (val != slot0)
 807           free (val);
 808         sv[n].val = val = xcharalloc (size);
 809         quotearg_buffer_restyled (val, size, arg, argsize, options->style,
 810                                   flags, options->quote_these_too,
 811                                   options->left_quote,
 812                                   options->right_quote);
 813       }
 814
 815     errno = e;
 816     return val;
 817   }
 818 }
 819
 820 char *
 821 quotearg_n (int n, char const *arg)
 822 {
 823   return quotearg_n_options (n, arg, SIZE_MAX, &default_quoting_options);
 824 }
 825
 826 char *
 827 quotearg_n_mem (int n, char const *arg, size_t argsize)
 828 {
 829   return quotearg_n_options (n, arg, argsize, &default_quoting_options);
 830 }
 831
 832 char *
 833 quotearg (char const *arg)
 834 {
 835   return quotearg_n (0, arg);
 836 }
 837
 838 char *
 839 quotearg_mem (char const *arg, size_t argsize)
 840 {
 841   return quotearg_n_mem (0, arg, argsize);
 842 }
 843
 844 char *
 845 quotearg_n_style (int n, enum quoting_style s, char const *arg)
 846 {
 847   struct quoting_options const o = quoting_options_from_style (s);
 848   return quotearg_n_options (n, arg, SIZE_MAX, &o);
 849 }
 850
 851 char *
 852 quotearg_n_style_mem (int n, enum quoting_style s,
 853                       char const *arg, size_t argsize)
 854 {
 855   struct quoting_options const o = quoting_options_from_style (s);
 856   return quotearg_n_options (n, arg, argsize, &o);
 857 }
 858
 859 char *
 860 quotearg_style (enum quoting_style s, char const *arg)
 861 {
 862   return quotearg_n_style (0, s, arg);
 863 }
 864
 865 char *
 866 quotearg_style_mem (enum quoting_style s, char const *arg, size_t argsize)
 867 {
 868   return quotearg_n_style_mem (0, s, arg, argsize);
 869 }
 870
 871 char *
 872 quotearg_char_mem (char const *arg, size_t argsize, char ch)
 873 {
 874   struct quoting_options options;
 875   options = default_quoting_options;
 876   set_char_quoting (&options, ch, 1);
 877   return quotearg_n_options (0, arg, argsize, &options);
 878 }
 879
 880 char *
 881 quotearg_char (char const *arg, char ch)
 882 {
 883   return quotearg_char_mem (arg, SIZE_MAX, ch);
 884 }
 885
 886 char *
 887 quotearg_colon (char const *arg)
 888 {
 889   return quotearg_char (arg, ':');
 890 }
 891
 892 char *
 893 quotearg_colon_mem (char const *arg, size_t argsize)
 894 {
 895   return quotearg_char_mem (arg, argsize, ':');
 896 }
 897
 898 char *
 899 quotearg_n_custom (int n, char const *left_quote,
 900                    char const *right_quote, char const *arg)
 901 {
 902   return quotearg_n_custom_mem (n, left_quote, right_quote, arg,
 903                                 SIZE_MAX);
 904 }
 905
 906 char *
 907 quotearg_n_custom_mem (int n, char const *left_quote,
 908                        char const *right_quote,
 909                        char const *arg, size_t argsize)
 910 {
 911   struct quoting_options o = default_quoting_options;
 912   set_custom_quoting (&o, left_quote, right_quote);
 913   return quotearg_n_options (n, arg, argsize, &o);
 914 }
 915
 916 char *
 917 quotearg_custom (char const *left_quote, char const *right_quote,
 918                  char const *arg)
 919 {
 920   return quotearg_n_custom (0, left_quote, right_quote, arg);
 921 }
 922
 923 char *
 924 quotearg_custom_mem (char const *left_quote, char const *right_quote,
 925                      char const *arg, size_t argsize)
 926 {
 927   return quotearg_n_custom_mem (0, left_quote, right_quote, arg,
 928                                 argsize);
 929 }
 930
 931
 932 /* The quoting option used by the functions of quote.h.  */
 933 struct quoting_options quote_quoting_options =
 934   {
 935     locale_quoting_style,
 936     0,
 937     { 0 },
 938     NULL, NULL
 939   };
 940
 941 char const *
 942 quote_n_mem (int n, char const *arg, size_t argsize)
 943 {
 944   return quotearg_n_options (n, arg, argsize, &quote_quoting_options);
 945 }
 946
 947 char const *
 948 quote_mem (char const *arg, size_t argsize)
 949 {
 950   return quote_n_mem (0, arg, argsize);
 951 }
 952
 953 char const *
 954 quote_n (int n, char const *arg)
 955 {
 956   return quote_n_mem (n, arg, SIZE_MAX);
 957 }
 958
 959 char const *
 960 quote (char const *arg)
 961 {
 962   return quote_n (0, arg);
 963 }