lib/quotearg.c

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