[bison.git] / lib / quotearg.c

/* quotearg.c - quote arguments for output
   Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

/* Written by Paul Eggert <eggert@twinsun.com> */

#if HAVE_CONFIG_H
# include <config.h>
#endif

#if HAVE_STDDEF_H
# include <stddef.h>  /* For the definition of size_t on windows w/MSVC.  */
#endif
#include <sys/types.h>
#include "quotearg.h"
#include "xalloc.h"

#include <ctype.h>

#if ENABLE_NLS
# include <libintl.h>
# define _(text) gettext (text)
#else
# define _(text) text
#endif
#define N_(text) text

#if HAVE_LIMITS_H
# include <limits.h>
#endif
#ifndef CHAR_BIT
# define CHAR_BIT 8
#endif
#ifndef SIZE_MAX
# define SIZE_MAX ((size_t) -1)
#endif
#ifndef UCHAR_MAX
# define UCHAR_MAX ((unsigned char) -1)
#endif
#ifndef UINT_MAX
# define UINT_MAX ((unsigned int) -1)
#endif

#if HAVE_C_BACKSLASH_A
# define ALERT_CHAR '\a'
#else
# define ALERT_CHAR '\7'
#endif

#if HAVE_STDLIB_H
# include <stdlib.h>
#endif

#if HAVE_STRING_H
# include <string.h>
#endif

#if HAVE_WCHAR_H

/* BSD/OS 4.1 wchar.h requires FILE and struct tm to be declared.  */
# include <stdio.h>
# include <time.h>

# include <wchar.h>
#endif

#if !HAVE_MBRTOWC
/* Disable multibyte processing entirely.  Since MB_CUR_MAX is 1, the
   other macros are defined only for documentation and to satisfy C
   syntax.  */
# undef MB_CUR_MAX
# define MB_CUR_MAX 1
# define mbrtowc(pwc, s, n, ps) ((*(pwc) = *(s)) != 0)
# define iswprint(wc) ISPRINT ((unsigned char) (wc))
# undef HAVE_MBSINIT
#endif

#if !defined mbsinit && !HAVE_MBSINIT
# define mbsinit(ps) 1
#endif

#ifndef iswprint
# if HAVE_WCTYPE_H
#  include <wctype.h>
# endif
# if !defined iswprint && !HAVE_ISWPRINT
#  define iswprint(wc) 1
# endif
#endif

#define INT_BITS (sizeof (int) * CHAR_BIT)

#if defined (STDC_HEADERS) || (!defined (isascii) && !defined (HAVE_ISASCII))
# define IN_CTYPE_DOMAIN(c) 1
#else
# define IN_CTYPE_DOMAIN(c) isascii(c)
#endif

/* Undefine to protect against the definition in wctype.h of solaris2.6.   */
#undef ISPRINT
#define ISPRINT(c) (IN_CTYPE_DOMAIN (c) && isprint (c))

struct quoting_options
{
  /* Basic quoting style.  */
  enum quoting_style style;

  /* Quote the characters indicated by this bit vector even if the
     quoting style would not normally require them to be quoted.  */
  int quote_these_too[(UCHAR_MAX / INT_BITS) + 1];
};

/* Names of quoting styles.  */
char const *const quoting_style_args[] =
{
  "literal",
  "shell",
  "shell-always",
  "c",
  "escape",
  "locale",
  "clocale",
  0
};

/* Correspondences to quoting style names.  */
enum quoting_style const quoting_style_vals[] =
{
  literal_quoting_style,
  shell_quoting_style,
  shell_always_quoting_style,
  c_quoting_style,
  escape_quoting_style,
  locale_quoting_style,
  clocale_quoting_style
};

/* The default quoting options.  */
static struct quoting_options default_quoting_options;

/* Allocate a new set of quoting options, with contents initially identical
   to O if O is not null, or to the default if O is null.
   It is the caller's responsibility to free the result.  */
struct quoting_options *
clone_quoting_options (struct quoting_options *o)
{
  struct quoting_options *p
    = (struct quoting_options *) xmalloc (sizeof (struct quoting_options));
  *p = *(o ? o : &default_quoting_options);
  return p;
}

/* Get the value of O's quoting style.  If O is null, use the default.  */
enum quoting_style
get_quoting_style (struct quoting_options *o)
{
  return (o ? o : &default_quoting_options)->style;
}

/* In O (or in the default if O is null),
   set the value of the quoting style to S.  */
void
set_quoting_style (struct quoting_options *o, enum quoting_style s)
{
  (o ? o : &default_quoting_options)->style = s;
}

/* In O (or in the default if O is null),
   set the value of the quoting options for character C to I.
   Return the old value.  Currently, the only values defined for I are
   0 (the default) and 1 (which means to quote the character even if
   it would not otherwise be quoted).  */
int
set_char_quoting (struct quoting_options *o, char c, int i)
{
  unsigned char uc = c;
  int *p = (o ? o : &default_quoting_options)->quote_these_too + uc / INT_BITS;
  int shift = uc % INT_BITS;
  int r = (*p >> shift) & 1;
  *p ^= ((i & 1) ^ r) << shift;
  return r;
}

/* MSGID approximates a quotation mark.  Return its translation if it
   has one; otherwise, return either it or "\"", depending on S.  */
static char const *
gettext_quote (char const *msgid, enum quoting_style s)
{
  char const *translation = _(msgid);
  if (translation == msgid && s == clocale_quoting_style)
    translation = "\"";
  return translation;
}

/* Place into buffer BUFFER (of size BUFFERSIZE) a quoted version of
   argument ARG (of size ARGSIZE), using QUOTING_STYLE and the
   non-quoting-style part of O to control quoting.
   Terminate the output with a null character, and return the written
   size of the output, not counting the terminating null.
   If BUFFERSIZE is too small to store the output string, return the
   value that would have been returned had BUFFERSIZE been large enough.
   If ARGSIZE is -1, use the string length of the argument for ARGSIZE.

   This function acts like quotearg_buffer (BUFFER, BUFFERSIZE, ARG,
   ARGSIZE, O), except it uses QUOTING_STYLE instead of the quoting
   style specified by O, and O may not be null.  */

static size_t
quotearg_buffer_restyled (char *buffer, size_t buffersize,
			  char const *arg, size_t argsize,
			  enum quoting_style quoting_style,
			  struct quoting_options const *o)
{
  size_t i;
  size_t len = 0;
  char const *quote_string = 0;
  size_t quote_string_len = 0;
  int backslash_escapes = 0;
  int unibyte_locale = MB_CUR_MAX == 1;

#define STORE(c) \
    do \
      { \
	if (len < buffersize) \
	  buffer[len] = (c); \
	len++; \
      } \
    while (0)

  switch (quoting_style)
    {
    case c_quoting_style:
      STORE ('"');
      backslash_escapes = 1;
      quote_string = "\"";
      quote_string_len = 1;
      break;

    case escape_quoting_style:
      backslash_escapes = 1;
      break;

    case locale_quoting_style:
    case clocale_quoting_style:
      {
	/* Get translations for open and closing quotation marks.

	   The message catalog should translate "`" to a left
	   quotation mark suitable for the locale, and similarly for
	   "'".  If the catalog has no translation,
	   locale_quoting_style quotes `like this', and
	   clocale_quoting_style quotes "like this".

	   For example, an American English Unicode locale should
	   translate "`" to U+201C (LEFT DOUBLE QUOTATION MARK), and
	   should translate "'" to U+201D (RIGHT DOUBLE QUOTATION
	   MARK).  A British English Unicode locale should instead
	   translate these to U+2018 (LEFT SINGLE QUOTATION MARK) and
	   U+2019 (RIGHT SINGLE QUOTATION MARK), respectively.  */

	char const *left = gettext_quote (N_("`"), quoting_style);
	char const *right = gettext_quote (N_("'"), quoting_style);
	for (quote_string = left; *quote_string; quote_string++)
	  STORE (*quote_string);
	backslash_escapes = 1;
	quote_string = right;
	quote_string_len = strlen (quote_string);
      }
      break;

    case shell_always_quoting_style:
      STORE ('\'');
      quote_string = "'";
      quote_string_len = 1;
      break;

    default:
      break;
    }

  for (i = 0;  ! (argsize == (size_t) -1 ? arg[i] == '\0' : i == argsize);  i++)
    {
      unsigned char c;
      unsigned char esc;

      if (backslash_escapes
	  && quote_string_len
	  && i + quote_string_len <= argsize
	  && memcmp (arg + i, quote_string, quote_string_len) == 0)
	STORE ('\\');

      c = arg[i];
      switch (c)
	{
	case '\0':
	  if (backslash_escapes)
	    {
	      STORE ('\\');
	      STORE ('0');
	      STORE ('0');
	      c = '0';
	    }
	  break;

	case '?':
	  switch (quoting_style)
	    {
	    case shell_quoting_style:
	      goto use_shell_always_quoting_style;

	    case c_quoting_style:
	      if (i + 2 < argsize && arg[i + 1] == '?')
		switch (arg[i + 2])
		  {
		  case '!': case '\'':
		  case '(': case ')': case '-': case '/':
		  case '<': case '=': case '>':
		    /* Escape the second '?' in what would otherwise be
		       a trigraph.  */
		    c = arg[i + 2];
		    i += 2;
		    STORE ('?');
		    STORE ('\\');
		    STORE ('?');
		    break;
		  }
	      break;

	    default:
	      break;
	    }
	  break;

	case ALERT_CHAR: esc = 'a'; goto c_escape;
	case '\b': esc = 'b'; goto c_escape;
	case '\f': esc = 'f'; goto c_escape;
	case '\n': esc = 'n'; goto c_and_shell_escape;
	case '\r': esc = 'r'; goto c_and_shell_escape;
	case '\t': esc = 't'; goto c_and_shell_escape;
	case '\v': esc = 'v'; goto c_escape;
	case '\\': esc = c; goto c_and_shell_escape;

	c_and_shell_escape:
	  if (quoting_style == shell_quoting_style)
	    goto use_shell_always_quoting_style;
	c_escape:
	  if (backslash_escapes)
	    {
	      c = esc;
	      goto store_escape;
	    }
	  break;

	case '#': case '~':
	  if (i != 0)
	    break;
	  /* Fall through.  */
	case ' ':
	case '!': /* special in bash */
	case '"': case '$': case '&':
	case '(': case ')': case '*': case ';':
	case '<': case '>': case '[':
	case '^': /* special in old /bin/sh, e.g. SunOS 4.1.4 */
	case '`': case '|':
	  /* A shell special character.  In theory, '$' and '`' could
	     be the first bytes of multibyte characters, which means
	     we should check them with mbrtowc, but in practice this
	     doesn't happen so it's not worth worrying about.  */
	  if (quoting_style == shell_quoting_style)
	    goto use_shell_always_quoting_style;
	  break;

	case '\'':
	  switch (quoting_style)
	    {
	    case shell_quoting_style:
	      goto use_shell_always_quoting_style;

	    case shell_always_quoting_style:
	      STORE ('\'');
	      STORE ('\\');
	      STORE ('\'');
	      break;

	    default:
	      break;
	    }
	  break;

	case '%': case '+': case ',': case '-': case '.': case '/':
	case '0': case '1': case '2': case '3': case '4': case '5':
	case '6': case '7': case '8': case '9': case ':': case '=':
	case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
	case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
	case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
	case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
	case 'Y': case 'Z': case ']': case '_': case 'a': case 'b':
	case 'c': case 'd': case 'e': case 'f': case 'g': case 'h':
	case 'i': case 'j': case 'k': case 'l': case 'm': case 'n':
	case 'o': case 'p': case 'q': case 'r': case 's': case 't':
	case 'u': case 'v': case 'w': case 'x': case 'y': case 'z':
	case '{': case '}':
	  /* These characters don't cause problems, no matter what the
	     quoting style is.  They cannot start multibyte sequences.  */
	  break;

	default:
	  /* If we have a multibyte sequence, copy it until we reach
	     its end, find an error, or come back to the initial shift
	     state.  For C-like styles, if the sequence has
	     unprintable characters, escape the whole sequence, since
	     we can't easily escape single characters within it.  */
	  {
	    /* Length of multibyte sequence found so far.  */
	    size_t m;

	    int printable;

	    if (unibyte_locale)
	      {
		m = 1;
		printable = ISPRINT (c);
	      }
	    else
	      {
		mbstate_t mbstate;
		memset (&mbstate, 0, sizeof mbstate);

		m = 0;
		printable = 1;
		if (argsize == (size_t) -1)
		  argsize = strlen (arg);

		do
		  {
		    wchar_t w;
		    size_t bytes = mbrtowc (&w, &arg[i + m],
					    argsize - (i + m), &mbstate);
		    if (bytes == 0)
		      break;
		    else if (bytes == (size_t) -1)
		      {
			printable = 0;
			break;
		      }
		    else if (bytes == (size_t) -2)
		      {
			printable = 0;
			while (i + m < argsize && arg[i + m])
			  m++;
			break;
		      }
		    else
		      {
			if (! iswprint (w))
			  printable = 0;
			m += bytes;
		      }
		  }
		while (! mbsinit (&mbstate));
	      }

	    if (1 < m || (backslash_escapes && ! printable))
	      {
		/* Output a multibyte sequence, or an escaped
		   unprintable unibyte character.  */
		size_t ilim = i + m;

		for (;;)
		  {
		    if (backslash_escapes && ! printable)
		      {
			STORE ('\\');
			STORE ('0' + (c >> 6));
			STORE ('0' + ((c >> 3) & 7));
			c = '0' + (c & 7);
		      }
		    if (ilim <= i + 1)
		      break;
		    STORE (c);
		    c = arg[++i];
		  }

		goto store_c;
	      }
	  }
	}

      if (! (backslash_escapes
	     && o->quote_these_too[c / INT_BITS] & (1 << (c % INT_BITS))))
	goto store_c;

    store_escape:
      STORE ('\\');

    store_c:
      STORE (c);
    }

  if (quote_string)
    for (; *quote_string; quote_string++)
      STORE (*quote_string);

  if (len < buffersize)
    buffer[len] = '\0';
  return len;

 use_shell_always_quoting_style:
  return quotearg_buffer_restyled (buffer, buffersize, arg, argsize,
				   shell_always_quoting_style, o);
}

/* Place into buffer BUFFER (of size BUFFERSIZE) a quoted version of
   argument ARG (of size ARGSIZE), using O to control quoting.
   If O is null, use the default.
   Terminate the output with a null character, and return the written
   size of the output, not counting the terminating null.
   If BUFFERSIZE is too small to store the output string, return the
   value that would have been returned had BUFFERSIZE been large enough.
   If ARGSIZE is -1, use the string length of the argument for ARGSIZE.  */
size_t
quotearg_buffer (char *buffer, size_t buffersize,
		 char const *arg, size_t argsize,
		 struct quoting_options const *o)
{
  struct quoting_options const *p = o ? o : &default_quoting_options;
  return quotearg_buffer_restyled (buffer, buffersize, arg, argsize,
				   p->style, p);
}

/* Use storage slot N to return a quoted version of argument ARG.
   ARG is of size ARGSIZE, but if that is -1, ARG is a null-terminated string.
   OPTIONS specifies the quoting options.
   The returned value points to static storage that can be
   reused by the next call to this function with the same value of N.
   N must be nonnegative.  N is deliberately declared with type "int"
   to allow for future extensions (using negative values).  */
static char *
quotearg_n_options (int n, char const *arg, size_t argsize,
		    struct quoting_options const *options)
{
  /* Preallocate a slot 0 buffer, so that the caller can always quote
     one small component of a "memory exhausted" message in slot 0.  */
  static char slot0[256];
  static unsigned int nslots = 1;
  unsigned int n0 = n;
  struct slotvec
    {
      size_t size;
      char *val;
    };
  static struct slotvec slotvec0 = {sizeof slot0, slot0};
  static struct slotvec *slotvec = &slotvec0;

  if (n < 0)
    abort ();

  if (nslots <= n0)
    {
      unsigned int n1 = n0 + 1;
      size_t s = n1 * sizeof *slotvec;

      if (SIZE_MAX / UINT_MAX <= sizeof *slotvec
	  && n1 != s / sizeof *slotvec)
	xalloc_die ();

      if (slotvec == &slotvec0)
	{
	  slotvec = (struct slotvec *) xmalloc (sizeof *slotvec);
	  *slotvec = slotvec0;
	}
      slotvec = (struct slotvec *) xrealloc (slotvec, s);
      memset (slotvec + nslots, 0, (n1 - nslots) * sizeof *slotvec);
      nslots = n1;
    }

  {
    size_t size = slotvec[n].size;
    char *val = slotvec[n].val;
    size_t qsize = quotearg_buffer (val, size, arg, argsize, options);

    if (size <= qsize)
      {
	slotvec[n].size = size = qsize + 1;
	slotvec[n].val = val = xrealloc (val == slot0 ? 0 : val, size);
	quotearg_buffer (val, size, arg, argsize, options);
      }

    return val;
  }
}

char *
quotearg_n (int n, char const *arg)
{
  return quotearg_n_options (n, arg, (size_t) -1, &default_quoting_options);
}

char *
quotearg (char const *arg)
{
  return quotearg_n (0, arg);
}

/* Return quoting options for STYLE, with no extra quoting.  */
static struct quoting_options
quoting_options_from_style (enum quoting_style style)
{
  struct quoting_options o;
  o.style = style;
  memset (o.quote_these_too, 0, sizeof o.quote_these_too);
  return o;
}

char *
quotearg_n_style (int n, enum quoting_style s, char const *arg)
{
  struct quoting_options const o = quoting_options_from_style (s);
  return quotearg_n_options (n, arg, (size_t) -1, &o);
}

char *
quotearg_n_style_mem (int n, enum quoting_style s,
		      char const *arg, size_t argsize)
{
  struct quoting_options const o = quoting_options_from_style (s);
  return quotearg_n_options (n, arg, argsize, &o);
}

char *
quotearg_style (enum quoting_style s, char const *arg)
{
  return quotearg_n_style (0, s, arg);
}

char *
quotearg_char (char const *arg, char ch)
{
  struct quoting_options options;
  options = default_quoting_options;
  set_char_quoting (&options, ch, 1);
  return quotearg_n_options (0, arg, (size_t) -1, &options);
}

char *
quotearg_colon (char const *arg)
{
  return quotearg_char (arg, ':');
}
Commit	Line	Data
ff4a34be	1	/* quotearg.c - quote arguments for output
8434f222	2	Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
ff4a34be AD	3
	4	This program is free software; you can redistribute it and/or modify
	5	it under the terms of the GNU General Public License as published by
	6	the Free Software Foundation; either version 2, or (at your option)
	7	any later version.
	8
	9	This program is distributed in the hope that it will be useful,
	10	but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	GNU General Public License for more details.
	13
	14	You should have received a copy of the GNU General Public License
	15	along with this program; if not, write to the Free Software Foundation,
	16	Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
	17
	18	/* Written by Paul Eggert <eggert@twinsun.com> */
	19
	20	#if HAVE_CONFIG_H
	21	# include <config.h>
	22	#endif
	23
b0ce6046 AD	24	#if HAVE_STDDEF_H
	25	# include <stddef.h> /* For the definition of size_t on windows w/MSVC. */
	26	#endif
ff4a34be	27	#include <sys/types.h>
fab5b110 AD	28	#include "quotearg.h"
fab5b110 AD	29	#include "xalloc.h"
ff4a34be AD	30
	31	#include <ctype.h>
	32
	33	#if ENABLE_NLS
	34	# include <libintl.h>
	35	# define _(text) gettext (text)
	36	#else
	37	# define _(text) text
	38	#endif
	39	#define N_(text) text
	40
	41	#if HAVE_LIMITS_H
	42	# include <limits.h>
	43	#endif
	44	#ifndef CHAR_BIT
	45	# define CHAR_BIT 8
	46	#endif
f4e421e6 AD	47	#ifndef SIZE_MAX
	48	# define SIZE_MAX ((size_t) -1)
	49	#endif
ff4a34be AD	50	#ifndef UCHAR_MAX
	51	# define UCHAR_MAX ((unsigned char) -1)
	52	#endif
f4e421e6 AD	53	#ifndef UINT_MAX
	54	# define UINT_MAX ((unsigned int) -1)
	55	#endif
ff4a34be AD	56
	57	#if HAVE_C_BACKSLASH_A
	58	# define ALERT_CHAR '\a'
	59	#else
	60	# define ALERT_CHAR '\7'
	61	#endif
	62
	63	#if HAVE_STDLIB_H
	64	# include <stdlib.h>
	65	#endif
	66
	67	#if HAVE_STRING_H
	68	# include <string.h>
	69	#endif
	70
	71	#if HAVE_WCHAR_H
342b8b6e AD	72
	73	/* BSD/OS 4.1 wchar.h requires FILE and struct tm to be declared. */
	74	# include <stdio.h>
	75	# include <time.h>
	76
ff4a34be AD	77	# include <wchar.h>
	78	#endif
	79
b0ce6046	80	#if !HAVE_MBRTOWC
ff4a34be AD	81	/* Disable multibyte processing entirely. Since MB_CUR_MAX is 1, the
	82	other macros are defined only for documentation and to satisfy C
	83	syntax. */
	84	# undef MB_CUR_MAX
	85	# define MB_CUR_MAX 1
	86	# define mbrtowc(pwc, s, n, ps) (((pwc) = (s)) != 0)
ff4a34be	87	# define iswprint(wc) ISPRINT ((unsigned char) (wc))
342b8b6e AD	88	# undef HAVE_MBSINIT
	89	#endif
	90
	91	#if !defined mbsinit && !HAVE_MBSINIT
	92	# define mbsinit(ps) 1
ff4a34be AD	93	#endif
	94
	95	#ifndef iswprint
	96	# if HAVE_WCTYPE_H
	97	# include <wctype.h>
	98	# endif
	99	# if !defined iswprint && !HAVE_ISWPRINT
	100	# define iswprint(wc) 1
	101	# endif
	102	#endif
	103
	104	#define INT_BITS (sizeof (int) * CHAR_BIT)
	105
	106	#if defined (STDC_HEADERS) \|\| (!defined (isascii) && !defined (HAVE_ISASCII))
	107	# define IN_CTYPE_DOMAIN(c) 1
	108	#else
	109	# define IN_CTYPE_DOMAIN(c) isascii(c)
	110	#endif
	111
	112	/* Undefine to protect against the definition in wctype.h of solaris2.6. */
	113	#undef ISPRINT
	114	#define ISPRINT(c) (IN_CTYPE_DOMAIN (c) && isprint (c))
	115
	116	struct quoting_options
	117	{
	118	/* Basic quoting style. */
	119	enum quoting_style style;
	120
	121	/* Quote the characters indicated by this bit vector even if the
	122	quoting style would not normally require them to be quoted. */
	123	int quote_these_too[(UCHAR_MAX / INT_BITS) + 1];
	124	};
	125
	126	/* Names of quoting styles. */
	127	char const *const quoting_style_args[] =
	128	{
	129	"literal",
	130	"shell",
	131	"shell-always",
	132	"c",
	133	"escape",
	134	"locale",
	135	"clocale",
	136	0
	137	};
	138
	139	/* Correspondences to quoting style names. */
	140	enum quoting_style const quoting_style_vals[] =
	141	{
	142	literal_quoting_style,
	143	shell_quoting_style,
	144	shell_always_quoting_style,
	145	c_quoting_style,
	146	escape_quoting_style,
	147	locale_quoting_style,
	148	clocale_quoting_style
	149	};
	150
	151	/* The default quoting options. */
	152	static struct quoting_options default_quoting_options;
	153
	154	/* Allocate a new set of quoting options, with contents initially identical
	155	to O if O is not null, or to the default if O is null.
	156	It is the caller's responsibility to free the result. */
157	struct quoting_options *
158	clone_quoting_options (struct quoting_options *o)
159	{
160	struct quoting_options *p
161	= (struct quoting_options *) xmalloc (sizeof (struct quoting_options));
162	p = (o ? o : &default_quoting_options);
163	return p;
164	}
165
166	/* Get the value of O's quoting style. If O is null, use the default. */
167	enum quoting_style
168	get_quoting_style (struct quoting_options *o)
169	{
170	return (o ? o : &default_quoting_options)->style;
171	}
172
173	/* In O (or in the default if O is null),
174	set the value of the quoting style to S. */
175	void
176	set_quoting_style (struct quoting_options *o, enum quoting_style s)
177	{
178	(o ? o : &default_quoting_options)->style = s;
179	}
180
181	/* In O (or in the default if O is null),
182	set the value of the quoting options for character C to I.
183	Return the old value. Currently, the only values defined for I are
184	0 (the default) and 1 (which means to quote the character even if
185	it would not otherwise be quoted). */
186	int
187	set_char_quoting (struct quoting_options *o, char c, int i)
188	{
189	unsigned char uc = c;
190	int *p = (o ? o : &default_quoting_options)->quote_these_too + uc / INT_BITS;
191	int shift = uc % INT_BITS;
192	int r = (*p >> shift) & 1;
193	*p ^= ((i & 1) ^ r) << shift;
194	return r;
195	}
196
197	/* MSGID approximates a quotation mark. Return its translation if it
198	has one; otherwise, return either it or "\"", depending on S. */
199	static char const *
200	gettext_quote (char const *msgid, enum quoting_style s)
201	{
202	char const *translation = _(msgid);
203	if (translation == msgid && s == clocale_quoting_style)
204	translation = "\"";
205	return translation;
206	}
207
208	/* Place into buffer BUFFER (of size BUFFERSIZE) a quoted version of
209	argument ARG (of size ARGSIZE), using QUOTING_STYLE and the
210	non-quoting-style part of O to control quoting.
211	Terminate the output with a null character, and return the written
212	size of the output, not counting the terminating null.
213	If BUFFERSIZE is too small to store the output string, return the
214	value that would have been returned had BUFFERSIZE been large enough.
215	If ARGSIZE is -1, use the string length of the argument for ARGSIZE.
216
217	This function acts like quotearg_buffer (BUFFER, BUFFERSIZE, ARG,
218	ARGSIZE, O), except it uses QUOTING_STYLE instead of the quoting
219	style specified by O, and O may not be null. */
220
221	static size_t
222	quotearg_buffer_restyled (char *buffer, size_t buffersize,
223	char const *arg, size_t argsize,
224	enum quoting_style quoting_style,
225	struct quoting_options const *o)
226	{
227	size_t i;
228	size_t len = 0;
229	char const *quote_string = 0;
230	size_t quote_string_len = 0;
231	int backslash_escapes = 0;
232	int unibyte_locale = MB_CUR_MAX == 1;
233
234	#define STORE(c) \
235	do \
236	{ \
237	if (len < buffersize) \
238	buffer[len] = (c); \
239	len++; \
240	} \
241	while (0)
242
243	switch (quoting_style)
244	{
245	case c_quoting_style:
246	STORE ('"');
247	backslash_escapes = 1;
248	quote_string = "\"";
249	quote_string_len = 1;
250	break;
251
252	case escape_quoting_style:
253	backslash_escapes = 1;
254	break;
255
256	case locale_quoting_style:
257	case clocale_quoting_style:
258	{
259	/* Get translations for open and closing quotation marks.
260
261	The message catalog should translate "`" to a left
262	quotation mark suitable for the locale, and similarly for
263	"'". If the catalog has no translation,
264	locale_quoting_style quotes `like this', and
265	clocale_quoting_style quotes "like this".
266
267	For example, an American English Unicode locale should
268	translate "`" to U+201C (LEFT DOUBLE QUOTATION MARK), and
269	should translate "'" to U+201D (RIGHT DOUBLE QUOTATION
270	MARK). A British English Unicode locale should instead
271	translate these to U+2018 (LEFT SINGLE QUOTATION MARK) and
272	U+2019 (RIGHT SINGLE QUOTATION MARK), respectively. */
273
274	char const *left = gettext_quote (N_("`"), quoting_style);
275	char const *right = gettext_quote (N_("'"), quoting_style);
276	for (quote_string = left; *quote_string; quote_string++)
277	STORE (*quote_string);
278	backslash_escapes = 1;
279	quote_string = right;
280	quote_string_len = strlen (quote_string);
281	}
282	break;
283
284	case shell_always_quoting_style:
285	STORE ('\'');
286	quote_string = "'";
287	quote_string_len = 1;
288	break;
289
290	default:
291	break;
292	}
293
294	for (i = 0; ! (argsize == (size_t) -1 ? arg[i] == '\0' : i == argsize); i++)
295	{
296	unsigned char c;
297	unsigned char esc;
298
299	if (backslash_escapes
300	&& quote_string_len
301	&& i + quote_string_len <= argsize
302	&& memcmp (arg + i, quote_string, quote_string_len) == 0)
303	STORE ('\\');
304
305	c = arg[i];
306	switch (c)
307	{
8434f222 PE	308	case '\0':
	309	if (backslash_escapes)
	310	{
	311	STORE ('\\');
	312	STORE ('0');
	313	STORE ('0');
	314	c = '0';
	315	}
	316	break;
	317
ff4a34be AD	318	case '?':
	319	switch (quoting_style)
	320	{
	321	case shell_quoting_style:
	322	goto use_shell_always_quoting_style;
	323
	324	case c_quoting_style:
	325	if (i + 2 < argsize && arg[i + 1] == '?')
	326	switch (arg[i + 2])
	327	{
	328	case '!': case '\'':
	329	case '(': case ')': case '-': case '/':
	330	case '<': case '=': case '>':
	331	/* Escape the second '?' in what would otherwise be
	332	a trigraph. */
ff4a34be	333	c = arg[i + 2];
9e4c5cb8	334	i += 2;
ff4a34be AD	335	STORE ('?');
	336	STORE ('\\');
	337	STORE ('?');
	338	break;
	339	}
	340	break;
	341
	342	default:
	343	break;
	344	}
	345	break;
	346
	347	case ALERT_CHAR: esc = 'a'; goto c_escape;
	348	case '\b': esc = 'b'; goto c_escape;
	349	case '\f': esc = 'f'; goto c_escape;
	350	case '\n': esc = 'n'; goto c_and_shell_escape;
	351	case '\r': esc = 'r'; goto c_and_shell_escape;
	352	case '\t': esc = 't'; goto c_and_shell_escape;
	353	case '\v': esc = 'v'; goto c_escape;
	354	case '\\': esc = c; goto c_and_shell_escape;
	355
	356	c_and_shell_escape:
	357	if (quoting_style == shell_quoting_style)
	358	goto use_shell_always_quoting_style;
	359	c_escape:
	360	if (backslash_escapes)
	361	{
	362	c = esc;
	363	goto store_escape;
	364	}
	365	break;
	366
	367	case '#': case '~':
	368	if (i != 0)
	369	break;
	370	/* Fall through. */
	371	case ' ':
	372	case '!': /* special in bash */
	373	case '"': case '$': case '&':
	374	case '(': case ')': case '*': case ';':
	375	case '<': case '>': case '[':
	376	case '^': /* special in old /bin/sh, e.g. SunOS 4.1.4 */
	377	case '`': case '\|':
	378	/* A shell special character. In theory, '$' and '`' could
	379	be the first bytes of multibyte characters, which means
	380	we should check them with mbrtowc, but in practice this
	381	doesn't happen so it's not worth worrying about. */
	382	if (quoting_style == shell_quoting_style)
	383	goto use_shell_always_quoting_style;
	384	break;
	385
	386	case '\'':
	387	switch (quoting_style)
	388	{
	389	case shell_quoting_style:
	390	goto use_shell_always_quoting_style;
	391
	392	case shell_always_quoting_style:
	393	STORE ('\'');
	394	STORE ('\\');
	395	STORE ('\'');
	396	break;
	397
	398	default:
399	break;
400	}
401	break;
402
403	case '%': case '+': case ',': case '-': case '.': case '/':
404	case '0': case '1': case '2': case '3': case '4': case '5':
405	case '6': case '7': case '8': case '9': case ':': case '=':
406	case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
407	case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
408	case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
409	case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
410	case 'Y': case 'Z': case ']': case '_': case 'a': case 'b':
411	case 'c': case 'd': case 'e': case 'f': case 'g': case 'h':
412	case 'i': case 'j': case 'k': case 'l': case 'm': case 'n':
413	case 'o': case 'p': case 'q': case 'r': case 's': case 't':
414	case 'u': case 'v': case 'w': case 'x': case 'y': case 'z':
415	case '{': case '}':
416	/* These characters don't cause problems, no matter what the
417	quoting style is. They cannot start multibyte sequences. */
418	break;
419
420	default:
421	/* If we have a multibyte sequence, copy it until we reach
422	its end, find an error, or come back to the initial shift
423	state. For C-like styles, if the sequence has
424	unprintable characters, escape the whole sequence, since
425	we can't easily escape single characters within it. */
426	{
427	/* Length of multibyte sequence found so far. */
428	size_t m;
429
430	int printable;
431
432	if (unibyte_locale)
433	{
434	m = 1;
435	printable = ISPRINT (c);
436	}
437	else
438	{
439	mbstate_t mbstate;
440	memset (&mbstate, 0, sizeof mbstate);
441
442	m = 0;
443	printable = 1;
444	if (argsize == (size_t) -1)
445	argsize = strlen (arg);
446
447	do
448	{
449	wchar_t w;
450	size_t bytes = mbrtowc (&w, &arg[i + m],
451	argsize - (i + m), &mbstate);
452	if (bytes == 0)
453	break;
454	else if (bytes == (size_t) -1)
455	{
456	printable = 0;
457	break;
458	}
459	else if (bytes == (size_t) -2)
460	{
461	printable = 0;
462	while (i + m < argsize && arg[i + m])
463	m++;
464	break;
465	}
466	else
467	{
468	if (! iswprint (w))
469	printable = 0;
470	m += bytes;
471	}
472	}
473	while (! mbsinit (&mbstate));
474	}
475
476	if (1 < m \|\| (backslash_escapes && ! printable))
477	{
478	/* Output a multibyte sequence, or an escaped
479	unprintable unibyte character. */
480	size_t ilim = i + m;
481
482	for (;;)
483	{
484	if (backslash_escapes && ! printable)
485	{
486	STORE ('\\');
487	STORE ('0' + (c >> 6));
488	STORE ('0' + ((c >> 3) & 7));
489	c = '0' + (c & 7);
490	}
491	if (ilim <= i + 1)
492	break;
493	STORE (c);
494	c = arg[++i];
495	}
496
497	goto store_c;
498	}
499	}
500	}
501
502	if (! (backslash_escapes
503	&& o->quote_these_too[c / INT_BITS] & (1 << (c % INT_BITS))))
504	goto store_c;
505
506	store_escape:
507	STORE ('\\');
508
509	store_c:
510	STORE (c);
511	}
512
513	if (quote_string)
514	for (; *quote_string; quote_string++)
515	STORE (*quote_string);
516
517	if (len < buffersize)
518	buffer[len] = '\0';
519	return len;
520
521	use_shell_always_quoting_style:
522	return quotearg_buffer_restyled (buffer, buffersize, arg, argsize,
523	shell_always_quoting_style, o);
524	}
525
526	/* Place into buffer BUFFER (of size BUFFERSIZE) a quoted version of
527	argument ARG (of size ARGSIZE), using O to control quoting.
528	If O is null, use the default.
529	Terminate the output with a null character, and return the written
530	size of the output, not counting the terminating null.
531	If BUFFERSIZE is too small to store the output string, return the
532	value that would have been returned had BUFFERSIZE been large enough.
533	If ARGSIZE is -1, use the string length of the argument for ARGSIZE. */
534	size_t
535	quotearg_buffer (char *buffer, size_t buffersize,
536	char const *arg, size_t argsize,
537	struct quoting_options const *o)
538	{
539	struct quoting_options const *p = o ? o : &default_quoting_options;
540	return quotearg_buffer_restyled (buffer, buffersize, arg, argsize,
541	p->style, p);
542	}
543
8434f222 PE	544	/* Use storage slot N to return a quoted version of argument ARG.
8434f222 PE	545	ARG is of size ARGSIZE, but if that is -1, ARG is a null-terminated string.
ff4a34be AD	546	OPTIONS specifies the quoting options.
	547	The returned value points to static storage that can be
	548	reused by the next call to this function with the same value of N.
	549	N must be nonnegative. N is deliberately declared with type "int"
	550	to allow for future extensions (using negative values). */
	551	static char *
8434f222	552	quotearg_n_options (int n, char const *arg, size_t argsize,
ff4a34be AD	553	struct quoting_options const *options)
	554	{
	555	/* Preallocate a slot 0 buffer, so that the caller can always quote
	556	one small component of a "memory exhausted" message in slot 0. */
	557	static char slot0[256];
	558	static unsigned int nslots = 1;
f4e421e6	559	unsigned int n0 = n;
ff4a34be AD	560	struct slotvec
	561	{
	562	size_t size;
	563	char *val;
	564	};
	565	static struct slotvec slotvec0 = {sizeof slot0, slot0};
	566	static struct slotvec *slotvec = &slotvec0;
	567
f4e421e6 AD	568	if (n < 0)
	569	abort ();
	570
	571	if (nslots <= n0)
ff4a34be	572	{
f4e421e6 AD	573	unsigned int n1 = n0 + 1;
	574	size_t s = n1 * sizeof *slotvec;
	575
	576	if (SIZE_MAX / UINT_MAX <= sizeof *slotvec
	577	&& n1 != s / sizeof *slotvec)
	578	xalloc_die ();
	579
ff4a34be AD	580	if (slotvec == &slotvec0)
ff4a34be AD	581	{
f4e421e6	582	slotvec = (struct slotvec ) xmalloc (sizeof slotvec);
ff4a34be AD	583	*slotvec = slotvec0;
	584	}
	585	slotvec = (struct slotvec *) xrealloc (slotvec, s);
f4e421e6 AD	586	memset (slotvec + nslots, 0, (n1 - nslots) * sizeof *slotvec);
f4e421e6 AD	587	nslots = n1;
ff4a34be AD	588	}
	589
	590	{
	591	size_t size = slotvec[n].size;
	592	char *val = slotvec[n].val;
8434f222	593	size_t qsize = quotearg_buffer (val, size, arg, argsize, options);
ff4a34be AD	594
	595	if (size <= qsize)
	596	{
	597	slotvec[n].size = size = qsize + 1;
	598	slotvec[n].val = val = xrealloc (val == slot0 ? 0 : val, size);
8434f222	599	quotearg_buffer (val, size, arg, argsize, options);
ff4a34be AD	600	}
	601
	602	return val;
	603	}
	604	}
	605
	606	char *
f4e421e6	607	quotearg_n (int n, char const *arg)
ff4a34be	608	{
8434f222	609	return quotearg_n_options (n, arg, (size_t) -1, &default_quoting_options);
ff4a34be AD	610	}
	611
	612	char *
	613	quotearg (char const *arg)
	614	{
	615	return quotearg_n (0, arg);
	616	}
	617
8434f222 PE	618	/* Return quoting options for STYLE, with no extra quoting. */
	619	static struct quoting_options
	620	quoting_options_from_style (enum quoting_style style)
ff4a34be AD	621	{
ff4a34be AD	622	struct quoting_options o;
8434f222	623	o.style = style;
ff4a34be	624	memset (o.quote_these_too, 0, sizeof o.quote_these_too);
8434f222 PE	625	return o;
	626	}
	627
	628	char *
	629	quotearg_n_style (int n, enum quoting_style s, char const *arg)
	630	{
	631	struct quoting_options const o = quoting_options_from_style (s);
	632	return quotearg_n_options (n, arg, (size_t) -1, &o);
	633	}
	634
	635	char *
	636	quotearg_n_style_mem (int n, enum quoting_style s,
	637	char const *arg, size_t argsize)
	638	{
	639	struct quoting_options const o = quoting_options_from_style (s);
	640	return quotearg_n_options (n, arg, argsize, &o);
ff4a34be AD	641	}
	642
	643	char *
	644	quotearg_style (enum quoting_style s, char const *arg)
	645	{
	646	return quotearg_n_style (0, s, arg);
	647	}
	648
	649	char *
	650	quotearg_char (char const *arg, char ch)
	651	{
	652	struct quoting_options options;
	653	options = default_quoting_options;
	654	set_char_quoting (&options, ch, 1);
8434f222	655	return quotearg_n_options (0, arg, (size_t) -1, &options);
ff4a34be AD	656	}
	657
	658	char *
	659	quotearg_colon (char const *arg)
	660	{
	661	return quotearg_char (arg, ':');
	662	}