| 1 | /* quotearg.c - quote arguments for output
|
|---|
| 2 |
|
|---|
| 3 | Copyright (C) 1998-2002, 2004-2012 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 quote_n and quote. */
|
|---|
| 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 (int n, char const *name)
|
|---|
| 943 | {
|
|---|
| 944 | return quotearg_n_options (n, name, SIZE_MAX, "e_quoting_options);
|
|---|
| 945 | }
|
|---|
| 946 |
|
|---|
| 947 | char const *
|
|---|
| 948 | quote (char const *name)
|
|---|
| 949 | {
|
|---|
| 950 | return quote_n (0, name);
|
|---|
| 951 | }
|
|---|