[bison.git] / lib / quotearg.c

/* quotearg.c - quote arguments for output
   Copyright (C) 1998, 1999, 2000, 2001 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 '?':
	  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.  */
		    i += 2;
		    c = arg[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 the string ARG.
   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,
		    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, (size_t) -1, 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, (size_t) -1, options);
      }

    return val;
  }
}

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

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

char *
quotearg_n_style (int n, enum quoting_style s, char const *arg)
{
  struct quoting_options o;
  o.style = s;
  memset (o.quote_these_too, 0, sizeof o.quote_these_too);
  return quotearg_n_options (n, arg, &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, &options);
}

char *
quotearg_colon (char const *arg)
{
  return quotearg_char (arg, ':');
}
Commit	Line	Data
ff4a34be	1	/* quotearg.c - quote arguments for output
b0ce6046	2	Copyright (C) 1998, 1999, 2000, 2001 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 AD	27	#include <sys/types.h>
	28	#include <quotearg.h>
	29	#include <xalloc.h>
	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	{
308	case '?':
309	switch (quoting_style)
310	{
311	case shell_quoting_style:
312	goto use_shell_always_quoting_style;
313
314	case c_quoting_style:
315	if (i + 2 < argsize && arg[i + 1] == '?')
316	switch (arg[i + 2])
317	{
318	case '!': case '\'':
319	case '(': case ')': case '-': case '/':
320	case '<': case '=': case '>':
321	/* Escape the second '?' in what would otherwise be
322	a trigraph. */
323	i += 2;
324	c = arg[i + 2];
325	STORE ('?');
326	STORE ('\\');
327	STORE ('?');
328	break;
329	}
330	break;
331
332	default:
333	break;
334	}
335	break;
336
337	case ALERT_CHAR: esc = 'a'; goto c_escape;
338	case '\b': esc = 'b'; goto c_escape;
339	case '\f': esc = 'f'; goto c_escape;
340	case '\n': esc = 'n'; goto c_and_shell_escape;
341	case '\r': esc = 'r'; goto c_and_shell_escape;
342	case '\t': esc = 't'; goto c_and_shell_escape;
343	case '\v': esc = 'v'; goto c_escape;
344	case '\\': esc = c; goto c_and_shell_escape;
345
346	c_and_shell_escape:
347	if (quoting_style == shell_quoting_style)
348	goto use_shell_always_quoting_style;
349	c_escape:
350	if (backslash_escapes)
351	{
352	c = esc;
353	goto store_escape;
354	}
355	break;
356
357	case '#': case '~':
358	if (i != 0)
359	break;
360	/* Fall through. */
361	case ' ':
362	case '!': /* special in bash */
363	case '"': case '$': case '&':
364	case '(': case ')': case '*': case ';':
365	case '<': case '>': case '[':
366	case '^': /* special in old /bin/sh, e.g. SunOS 4.1.4 */
367	case '`': case '\|':
368	/* A shell special character. In theory, '$' and '`' could
369	be the first bytes of multibyte characters, which means
370	we should check them with mbrtowc, but in practice this
371	doesn't happen so it's not worth worrying about. */
372	if (quoting_style == shell_quoting_style)
373	goto use_shell_always_quoting_style;
374	break;
375
376	case '\'':
377	switch (quoting_style)
378	{
379	case shell_quoting_style:
380	goto use_shell_always_quoting_style;
381
382	case shell_always_quoting_style:
383	STORE ('\'');
384	STORE ('\\');
385	STORE ('\'');
386	break;
387
388	default:
389	break;
390	}
391	break;
392
393	case '%': case '+': case ',': case '-': case '.': case '/':
394	case '0': case '1': case '2': case '3': case '4': case '5':
395	case '6': case '7': case '8': case '9': case ':': case '=':
396	case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
397	case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
398	case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
399	case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
400	case 'Y': case 'Z': case ']': case '_': case 'a': case 'b':
401	case 'c': case 'd': case 'e': case 'f': case 'g': case 'h':
402	case 'i': case 'j': case 'k': case 'l': case 'm': case 'n':
403	case 'o': case 'p': case 'q': case 'r': case 's': case 't':
404	case 'u': case 'v': case 'w': case 'x': case 'y': case 'z':
405	case '{': case '}':
406	/* These characters don't cause problems, no matter what the
407	quoting style is. They cannot start multibyte sequences. */
408	break;
409
410	default:
411	/* If we have a multibyte sequence, copy it until we reach
412	its end, find an error, or come back to the initial shift
413	state. For C-like styles, if the sequence has
414	unprintable characters, escape the whole sequence, since
415	we can't easily escape single characters within it. */
416	{
417	/* Length of multibyte sequence found so far. */
418	size_t m;
419
420	int printable;
421
422	if (unibyte_locale)
423	{
424	m = 1;
425	printable = ISPRINT (c);
426	}
427	else
428	{
429	mbstate_t mbstate;
430	memset (&mbstate, 0, sizeof mbstate);
431
432	m = 0;
433	printable = 1;
434	if (argsize == (size_t) -1)
435	argsize = strlen (arg);
436
437	do
438	{
439	wchar_t w;
440	size_t bytes = mbrtowc (&w, &arg[i + m],
441	argsize - (i + m), &mbstate);
442	if (bytes == 0)
443	break;
444	else if (bytes == (size_t) -1)
445	{
446	printable = 0;
447	break;
448	}
449	else if (bytes == (size_t) -2)
450	{
451	printable = 0;
452	while (i + m < argsize && arg[i + m])
453	m++;
454	break;
455	}
456	else
457	{
458	if (! iswprint (w))
459	printable = 0;
460	m += bytes;
461	}
462	}
463	while (! mbsinit (&mbstate));
464	}
465
466	if (1 < m \|\| (backslash_escapes && ! printable))
467	{
468	/* Output a multibyte sequence, or an escaped
469	unprintable unibyte character. */
470	size_t ilim = i + m;
471
472	for (;;)
473	{
474	if (backslash_escapes && ! printable)
475	{
476	STORE ('\\');
477	STORE ('0' + (c >> 6));
478	STORE ('0' + ((c >> 3) & 7));
479	c = '0' + (c & 7);
480	}
481	if (ilim <= i + 1)
482	break;
483	STORE (c);
484	c = arg[++i];
485	}
486
487	goto store_c;
488	}
489	}
490	}
491
492	if (! (backslash_escapes
493	&& o->quote_these_too[c / INT_BITS] & (1 << (c % INT_BITS))))
494	goto store_c;
495
496	store_escape:
497	STORE ('\\');
498
499	store_c:
500	STORE (c);
501	}
502
503	if (quote_string)
504	for (; *quote_string; quote_string++)
505	STORE (*quote_string);
506
507	if (len < buffersize)
508	buffer[len] = '\0';
509	return len;
510
511	use_shell_always_quoting_style:
512	return quotearg_buffer_restyled (buffer, buffersize, arg, argsize,
513	shell_always_quoting_style, o);
514	}
515
516	/* Place into buffer BUFFER (of size BUFFERSIZE) a quoted version of
517	argument ARG (of size ARGSIZE), using O to control quoting.
518	If O is null, use the default.
519	Terminate the output with a null character, and return the written
520	size of the output, not counting the terminating null.
521	If BUFFERSIZE is too small to store the output string, return the
522	value that would have been returned had BUFFERSIZE been large enough.
523	If ARGSIZE is -1, use the string length of the argument for ARGSIZE. */
524	size_t
525	quotearg_buffer (char *buffer, size_t buffersize,
526	char const *arg, size_t argsize,
527	struct quoting_options const *o)
528	{
529	struct quoting_options const *p = o ? o : &default_quoting_options;
530	return quotearg_buffer_restyled (buffer, buffersize, arg, argsize,
531	p->style, p);
532	}
533
534	/* Use storage slot N to return a quoted version of the string ARG.
535	OPTIONS specifies the quoting options.
536	The returned value points to static storage that can be
537	reused by the next call to this function with the same value of N.
538	N must be nonnegative. N is deliberately declared with type "int"
539	to allow for future extensions (using negative values). */
540	static char *
541	quotearg_n_options (int n, char const *arg,
542	struct quoting_options const *options)
543	{
544	/* Preallocate a slot 0 buffer, so that the caller can always quote
545	one small component of a "memory exhausted" message in slot 0. */
546	static char slot0[256];
547	static unsigned int nslots = 1;
f4e421e6	548	unsigned int n0 = n;
ff4a34be AD	549	struct slotvec
	550	{
	551	size_t size;
	552	char *val;
	553	};
	554	static struct slotvec slotvec0 = {sizeof slot0, slot0};
	555	static struct slotvec *slotvec = &slotvec0;
	556
f4e421e6 AD	557	if (n < 0)
	558	abort ();
	559
	560	if (nslots <= n0)
ff4a34be	561	{
f4e421e6 AD	562	unsigned int n1 = n0 + 1;
	563	size_t s = n1 * sizeof *slotvec;
	564
	565	if (SIZE_MAX / UINT_MAX <= sizeof *slotvec
	566	&& n1 != s / sizeof *slotvec)
	567	xalloc_die ();
	568
ff4a34be AD	569	if (slotvec == &slotvec0)
ff4a34be AD	570	{
f4e421e6	571	slotvec = (struct slotvec ) xmalloc (sizeof slotvec);
ff4a34be AD	572	*slotvec = slotvec0;
	573	}
	574	slotvec = (struct slotvec *) xrealloc (slotvec, s);
f4e421e6 AD	575	memset (slotvec + nslots, 0, (n1 - nslots) * sizeof *slotvec);
f4e421e6 AD	576	nslots = n1;
ff4a34be AD	577	}
	578
	579	{
	580	size_t size = slotvec[n].size;
	581	char *val = slotvec[n].val;
	582	size_t qsize = quotearg_buffer (val, size, arg, (size_t) -1, options);
	583
	584	if (size <= qsize)
	585	{
	586	slotvec[n].size = size = qsize + 1;
	587	slotvec[n].val = val = xrealloc (val == slot0 ? 0 : val, size);
	588	quotearg_buffer (val, size, arg, (size_t) -1, options);
	589	}
	590
	591	return val;
	592	}
	593	}
	594
	595	char *
f4e421e6	596	quotearg_n (int n, char const *arg)
ff4a34be AD	597	{
	598	return quotearg_n_options (n, arg, &default_quoting_options);
	599	}
	600
	601	char *
	602	quotearg (char const *arg)
	603	{
	604	return quotearg_n (0, arg);
	605	}
	606
	607	char *
f4e421e6	608	quotearg_n_style (int n, enum quoting_style s, char const *arg)
ff4a34be AD	609	{
	610	struct quoting_options o;
	611	o.style = s;
	612	memset (o.quote_these_too, 0, sizeof o.quote_these_too);
	613	return quotearg_n_options (n, arg, &o);
	614	}
	615
	616	char *
	617	quotearg_style (enum quoting_style s, char const *arg)
	618	{
	619	return quotearg_n_style (0, s, arg);
	620	}
	621
	622	char *
	623	quotearg_char (char const *arg, char ch)
	624	{
	625	struct quoting_options options;
	626	options = default_quoting_options;
	627	set_char_quoting (&options, ch, 1);
	628	return quotearg_n_options (0, arg, &options);
	629	}
	630
	631	char *
	632	quotearg_colon (char const *arg)
	633	{
	634	return quotearg_char (arg, ':');
	635	}