contrib/diffutils/lib/quotearg.c

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