[thirdparty/bash.git] / locale.c

/* locale.c - Miscellaneous internationalization functions. */

/* Copyright (C) 1996-2009,2012,2016 Free Software Foundation, Inc.

   This file is part of GNU Bash, the Bourne Again SHell.

   Bash 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 3 of the License, or
   (at your option) any later version.

   Bash 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 Bash.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "config.h"

#include "bashtypes.h"

#if defined (HAVE_UNISTD_H)
#  include <unistd.h>
#endif

#if HAVE_LANGINFO_CODESET
#  include <langinfo.h>
#endif

#include "bashintl.h"
#include "bashansi.h"
#include <stdio.h>
#include "chartypes.h"
#include <errno.h>

#include "shell.h"
#include "input.h"	/* For bash_input */

#ifndef errno
extern int errno;
#endif

int locale_utf8locale;
int locale_mb_cur_max;	/* value of MB_CUR_MAX for current locale (LC_CTYPE) */
int locale_shiftstates;

extern int dump_translatable_strings, dump_po_strings;

/* The current locale when the program begins */
static char *default_locale;

/* The current domain for textdomain(3). */
static char *default_domain;
static char *default_dir;

/* tracks the value of LC_ALL; used to override values for other locale
   categories */
static char *lc_all;

/* tracks the value of LC_ALL; used to provide defaults for locale
   categories */
static char *lang;

/* Called to reset all of the locale variables to their appropriate values
   if (and only if) LC_ALL has not been assigned a value. */
static int reset_locale_vars __P((void));

static void locale_setblanks __P((void));
static int locale_isutf8 __P((char *));

/* Set the value of default_locale and make the current locale the
   system default locale.  This should be called very early in main(). */
void
set_default_locale ()
{
#if defined (HAVE_SETLOCALE)
  default_locale = setlocale (LC_ALL, "");
  if (default_locale)
    default_locale = savestring (default_locale);
#endif /* HAVE_SETLOCALE */
  bindtextdomain (PACKAGE, LOCALEDIR);
  textdomain (PACKAGE);

  locale_mb_cur_max = MB_CUR_MAX;
  locale_utf8locale = locale_isutf8 (default_locale);
  locale_shiftstates = mblen ((char *)NULL, 0);
}

/* Set default values for LC_CTYPE, LC_COLLATE, LC_MESSAGES, LC_NUMERIC and
   LC_TIME if they are not specified in the environment, but LC_ALL is.  This
   should be called from main() after parsing the environment. */
void
set_default_locale_vars ()
{
  char *val;

#if defined (HAVE_SETLOCALE)

#  if defined (LC_CTYPE)
  val = get_string_value ("LC_CTYPE");
  if (val == 0 && lc_all && *lc_all)
    {
      setlocale (LC_CTYPE, lc_all);
      locale_setblanks ();
      locale_mb_cur_max = MB_CUR_MAX;
      locale_utf8locale = locale_isutf8 (lc_all);
      locale_shiftstates = mblen ((char *)NULL, 0);
      u32reset ();
    }
#  endif

#  if defined (LC_COLLATE)
  val = get_string_value ("LC_COLLATE");
  if (val == 0 && lc_all && *lc_all)
    setlocale (LC_COLLATE, lc_all);
#  endif /* LC_COLLATE */

#  if defined (LC_MESSAGES)
  val = get_string_value ("LC_MESSAGES");
  if (val == 0 && lc_all && *lc_all)
    setlocale (LC_MESSAGES, lc_all);
#  endif /* LC_MESSAGES */

#  if defined (LC_NUMERIC)
  val = get_string_value ("LC_NUMERIC");
  if (val == 0 && lc_all && *lc_all)
    setlocale (LC_NUMERIC, lc_all);
#  endif /* LC_NUMERIC */

#  if defined (LC_TIME)
  val = get_string_value ("LC_TIME");
  if (val == 0 && lc_all && *lc_all)
    setlocale (LC_TIME, lc_all);
#  endif /* LC_TIME */

#endif /* HAVE_SETLOCALE */

  val = get_string_value ("TEXTDOMAIN");
  if (val && *val)
    {
      FREE (default_domain);
      default_domain = savestring (val);
      if (default_dir && *default_dir)
	bindtextdomain (default_domain, default_dir);
    }

  val = get_string_value ("TEXTDOMAINDIR");
  if (val && *val)
    {
      FREE (default_dir);
      default_dir = savestring (val);
      if (default_domain && *default_domain)
	bindtextdomain (default_domain, default_dir);
    }
}

/* Set one of the locale categories (specified by VAR) to VALUE.  Returns 1
  if successful, 0 otherwise. */
int
set_locale_var (var, value)
     char *var, *value;
{
  int r;
  char *x;

  x = "";
  errno = 0;
  if (var[0] == 'T' && var[10] == 0)		/* TEXTDOMAIN */
    {
      FREE (default_domain);
      default_domain = value ? savestring (value) : (char *)NULL;
      if (default_dir && *default_dir)
	bindtextdomain (default_domain, default_dir);
      return (1);
    }
  else if (var[0] == 'T')			/* TEXTDOMAINDIR */
    {
      FREE (default_dir);
      default_dir = value ? savestring (value) : (char *)NULL;
      if (default_domain && *default_domain)
	bindtextdomain (default_domain, default_dir);
      return (1);
    }

  /* var[0] == 'L' && var[1] == 'C' && var[2] == '_' */

  else if (var[3] == 'A')			/* LC_ALL */
    {
      FREE (lc_all);
      if (value)
	lc_all = savestring (value);
      else
	{
	  lc_all = (char *)xmalloc (1);
	  lc_all[0] = '\0';
	}
#if defined (HAVE_SETLOCALE)
      r = *lc_all ? ((x = setlocale (LC_ALL, lc_all)) != 0) : reset_locale_vars ();
      if (x == 0)
	{
	  if (errno == 0)
	    internal_warning(_("setlocale: LC_ALL: cannot change locale (%s)"), lc_all);
	  else
	    internal_warning(_("setlocale: LC_ALL: cannot change locale (%s): %s"), lc_all, strerror (errno));
	}
      locale_setblanks ();
      locale_mb_cur_max = MB_CUR_MAX;
      /* if LC_ALL == "", reset_locale_vars has already called this */
      if (*lc_all && x)
	locale_utf8locale = locale_isutf8 (lc_all);
      locale_shiftstates = mblen ((char *)NULL, 0);
      u32reset ();
      return r;
#else
      return (1);
#endif
    }

#if defined (HAVE_SETLOCALE)
  else if (var[3] == 'C' && var[4] == 'T')	/* LC_CTYPE */
    {
#  if defined (LC_CTYPE)
      if (lc_all == 0 || *lc_all == '\0')
	{
	  x = setlocale (LC_CTYPE, get_locale_var ("LC_CTYPE"));
	  locale_setblanks ();
	  locale_mb_cur_max = MB_CUR_MAX;
	  /* if setlocale() returns NULL, the locale is not changed */
	  if (x)
	    locale_utf8locale = locale_isutf8 (x);
	  locale_shiftstates = mblen ((char *)NULL, 0);
	  u32reset ();
	}
#  endif
    }
  else if (var[3] == 'C' && var[4] == 'O')	/* LC_COLLATE */
    {
#  if defined (LC_COLLATE)
      if (lc_all == 0 || *lc_all == '\0')
	x = setlocale (LC_COLLATE, get_locale_var ("LC_COLLATE"));
#  endif /* LC_COLLATE */
    }
  else if (var[3] == 'M' && var[4] == 'E')	/* LC_MESSAGES */
    {
#  if defined (LC_MESSAGES)
      if (lc_all == 0 || *lc_all == '\0')
	x = setlocale (LC_MESSAGES, get_locale_var ("LC_MESSAGES"));
#  endif /* LC_MESSAGES */
    }
  else if (var[3] == 'N' && var[4] == 'U')	/* LC_NUMERIC */
    {
#  if defined (LC_NUMERIC)
      if (lc_all == 0 || *lc_all == '\0')
	x = setlocale (LC_NUMERIC, get_locale_var ("LC_NUMERIC"));
#  endif /* LC_NUMERIC */
    }
  else if (var[3] == 'T' && var[4] == 'I')	/* LC_TIME */
    {
#  if defined (LC_TIME)
      if (lc_all == 0 || *lc_all == '\0')
	x = setlocale (LC_TIME, get_locale_var ("LC_TIME"));
#  endif /* LC_TIME */
    }
#endif /* HAVE_SETLOCALE */
  
  if (x == 0)
    {
      if (errno == 0)
	internal_warning(_("setlocale: %s: cannot change locale (%s)"), var, get_locale_var (var));
      else
	internal_warning(_("setlocale: %s: cannot change locale (%s): %s"), var, get_locale_var (var), strerror (errno));
    }

  return (x != 0);
}

/* Called when LANG is assigned a value.  Tracks value in `lang'.  Calls
   reset_locale_vars() to reset any default values if LC_ALL is unset or
   null. */
int
set_lang (var, value)
     char *var, *value;
{
  FREE (lang);
  if (value)
    lang = savestring (value);
  else
    {
      lang = (char *)xmalloc (1);
      lang[0] = '\0';
    }

  return ((lc_all == 0 || *lc_all == 0) ? reset_locale_vars () : 0);
}

/* Set default values for LANG and LC_ALL.  Default values for all other
   locale-related variables depend on these. */
void
set_default_lang ()
{
  char *v;

  v = get_string_value ("LC_ALL");
  set_locale_var ("LC_ALL", v);

  v = get_string_value ("LANG");
  set_lang ("LANG", v);
}

/* Get the value of one of the locale variables (LC_MESSAGES, LC_CTYPE).
   The precedence is as POSIX.2 specifies:  LC_ALL has precedence over
   the specific locale variables, and LANG, if set, is used as the default. */
char *
get_locale_var (var)
     char *var;
{
  char *locale;

  locale = lc_all;

  if (locale == 0 || *locale == 0)
    locale = get_string_value (var);	/* XXX - no mem leak */
  if (locale == 0 || *locale == 0)
    locale = lang;
  if (locale == 0 || *locale == 0)
#if 0
    locale = default_locale;	/* system-dependent; not really portable.  should it be "C"? */
#else
    locale = "";
#endif
  return (locale);
}

/* Called to reset all of the locale variables to their appropriate values
   if (and only if) LC_ALL has not been assigned a value.  DO NOT CALL THIS
   IF LC_ALL HAS BEEN ASSIGNED A VALUE. */
static int
reset_locale_vars ()
{
  char *t, *x;
#if defined (HAVE_SETLOCALE)
  if (lang == 0 || *lang == '\0')
    maybe_make_export_env ();		/* trust that this will change environment for setlocale */
  if (setlocale (LC_ALL, lang ? lang : "") == 0)
    return 0;

  x = 0;
#  if defined (LC_CTYPE)
  x = setlocale (LC_CTYPE, get_locale_var ("LC_CTYPE"));
#  endif
#  if defined (LC_COLLATE)
  t = setlocale (LC_COLLATE, get_locale_var ("LC_COLLATE"));
#  endif
#  if defined (LC_MESSAGES)
  t = setlocale (LC_MESSAGES, get_locale_var ("LC_MESSAGES"));
#  endif
#  if defined (LC_NUMERIC)
  t = setlocale (LC_NUMERIC, get_locale_var ("LC_NUMERIC"));
#  endif
#  if defined (LC_TIME)
  t = setlocale (LC_TIME, get_locale_var ("LC_TIME"));
#  endif

  locale_setblanks ();  
  locale_mb_cur_max = MB_CUR_MAX;
  if (x)
    locale_utf8locale = locale_isutf8 (x);
  locale_shiftstates = mblen ((char *)NULL, 0);
  u32reset ();
#endif
  return 1;
}

/* Translate the contents of STRING, a $"..." quoted string, according
   to the current locale.  In the `C' or `POSIX' locale, or if gettext()
   is not available, the passed string is returned unchanged.  The
   length of the translated string is returned in LENP, if non-null. */
char *
localetrans (string, len, lenp)
     char *string;
     int len, *lenp;
{
  char *locale, *t;
  char *translated;
  int tlen;

  /* Don't try to translate null strings. */
  if (string == 0 || *string == 0)
    {
      if (lenp)
	*lenp = 0;
      return ((char *)NULL);
    }

  locale = get_locale_var ("LC_MESSAGES");

  /* If we don't have setlocale() or the current locale is `C' or `POSIX',
     just return the string.  If we don't have gettext(), there's no use
     doing anything else. */
  if (locale == 0 || locale[0] == '\0' ||
      (locale[0] == 'C' && locale[1] == '\0') || STREQ (locale, "POSIX"))
    {
      t = (char *)xmalloc (len + 1);
      strcpy (t, string);
      if (lenp)
	*lenp = len;
      return (t);
    }

  /* Now try to translate it. */
  if (default_domain && *default_domain)
    translated = dgettext (default_domain, string);
  else
    translated = string;

  if (translated == string)	/* gettext returns its argument if untranslatable */
    {
      t = (char *)xmalloc (len + 1);
      strcpy (t, string);
      if (lenp)
	*lenp = len;
    }
  else
    {
      tlen = strlen (translated);
      t = (char *)xmalloc (tlen + 1);
      strcpy (t, translated);
      if (lenp)
	*lenp = tlen;
    }
  return (t);
}

/* Change a bash string into a string suitable for inclusion in a `po' file.
   This backslash-escapes `"' and `\' and changes newlines into \\\n"\n". */
char *
mk_msgstr (string, foundnlp)
     char *string;
     int *foundnlp;
{
  register int c, len;
  char *result, *r, *s;

  for (len = 0, s = string; s && *s; s++)
    {
      len++;
      if (*s == '"' || *s == '\\')
	len++;
      else if (*s == '\n')
	len += 5;
    }
  
  r = result = (char *)xmalloc (len + 3);
  *r++ = '"';

  for (s = string; s && (c = *s); s++)
    {
      if (c == '\n')	/* <NL> -> \n"<NL>" */
	{
	  *r++ = '\\';
	  *r++ = 'n';
	  *r++ = '"';
	  *r++ = '\n';
	  *r++ = '"';
	  if (foundnlp)
	    *foundnlp = 1;
	  continue;
	}
      if (c == '"' || c == '\\')
	*r++ = '\\';
      *r++ = c;
    }

  *r++ = '"';
  *r++ = '\0';

  return result;
}

/* $"..." -- Translate the portion of STRING between START and END
   according to current locale using gettext (if available) and return
   the result.  The caller will take care of leaving the quotes intact.
   The string will be left without the leading `$' by the caller.
   If translation is performed, the translated string will be double-quoted
   by the caller.  The length of the translated string is returned in LENP,
   if non-null. */
char *
localeexpand (string, start, end, lineno, lenp)
     char *string;
     int start, end, lineno, *lenp;
{
  int len, tlen, foundnl;
  char *temp, *t, *t2;

  temp = (char *)xmalloc (end - start + 1);
  for (tlen = 0, len = start; len < end; )
    temp[tlen++] = string[len++];
  temp[tlen] = '\0';

  /* If we're just dumping translatable strings, don't do anything with the
     string itself, but if we're dumping in `po' file format, convert it into
     a form more palatable to gettext(3) and friends by quoting `"' and `\'
     with backslashes and converting <NL> into `\n"<NL>"'.  If we find a
     newline in TEMP, we first output a `msgid ""' line and then the
     translated string; otherwise we output the `msgid' and translated
     string all on one line. */
  if (dump_translatable_strings)
    {
      if (dump_po_strings)
	{
	  foundnl = 0;
	  t = mk_msgstr (temp, &foundnl);
	  t2 = foundnl ? "\"\"\n" : "";

	  printf ("#: %s:%d\nmsgid %s%s\nmsgstr \"\"\n",
			yy_input_name (), lineno, t2, t);
	  free (t);
	}
      else
	printf ("\"%s\"\n", temp);

      if (lenp)
	*lenp = tlen;
      return (temp);
    }
  else if (*temp)
    {
      t = localetrans (temp, tlen, &len);
      free (temp);
      if (lenp)
	*lenp = len;
      return (t);
    }
  else
    {
      if (lenp)
	*lenp = 0;
      return (temp);
    }
}

/* Set every character in the <blank> character class to be a shell break
   character for the lexical analyzer when the locale changes. */
static void
locale_setblanks ()
{
  int x;

  for (x = 0; x < sh_syntabsiz; x++)
    {
      if (isblank ((unsigned char)x))
	sh_syntaxtab[x] |= CSHBRK|CBLANK;
      else if (member (x, shell_break_chars))
	{
	  sh_syntaxtab[x] |= CSHBRK;
	  sh_syntaxtab[x] &= ~CBLANK;
	}
      else
	sh_syntaxtab[x] &= ~(CSHBRK|CBLANK);
    }
}

/* Parse a locale specification
     language[_territory][.codeset][@modifier][+special][,[sponsor][_revision]]
   and return TRUE if the codeset is UTF-8 or utf8 */
static int
locale_isutf8 (lspec)
     char *lspec;
{
  char *cp, *encoding;

#if HAVE_LANGINFO_CODESET
  cp = nl_langinfo (CODESET);
  return (STREQ (cp, "UTF-8") || STREQ (cp, "utf8"));
#elif HAVE_LOCALE_CHARSET
  cp = locale_charset ();
  return (STREQ (cp, "UTF-8") || STREQ (cp, "utf8"));
#else
  /* Take a shot */
  for (cp = lspec; *cp && *cp != '@' && *cp != '+' && *cp != ','; cp++)
    {
      if (*cp == '.')
	{
	  for (encoding = ++cp; *cp && *cp != '@' && *cp != '+' && *cp != ','; cp++)
	    ;
	  /* The encoding (codeset) is the substring between encoding and cp */
	  if ((cp - encoding == 5 && STREQN (encoding, "UTF-8", 5)) ||
	      (cp - encoding == 4 && STREQN (encoding, "utf8", 4)))
	    return 1;
	  else
	    return 0;
	}
    }
  return 0;
#endif
}

#if defined (HAVE_LOCALECONV)
int
locale_decpoint ()
{
  struct lconv *lv;

  lv = localeconv ();
  return (lv && lv->decimal_point && lv->decimal_point[0]) ? lv->decimal_point[0] : '.';
}
#else
#  undef locale_decpoint
int
locale_decpoint ()
{
  return '.';
}
#endif
Commit	Line	Data
ccc6cda3 JA	1	/* locale.c - Miscellaneous internationalization functions. */
ccc6cda3 JA	2
d233b485	3	/* Copyright (C) 1996-2009,2012,2016 Free Software Foundation, Inc.
ccc6cda3 JA	4
	5	This file is part of GNU Bash, the Bourne Again SHell.
	6
3185942a JA	7	Bash is free software: you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation, either version 3 of the License, or
	10	(at your option) any later version.
ccc6cda3	11
3185942a JA	12	Bash is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
ccc6cda3	16
3185942a JA	17	You should have received a copy of the GNU General Public License
	18	along with Bash. If not, see <http://www.gnu.org/licenses/>.
	19	*/
ccc6cda3 JA	20
	21	#include "config.h"
	22
	23	#include "bashtypes.h"
	24
	25	#if defined (HAVE_UNISTD_H)
	26	# include <unistd.h>
	27	#endif
	28
ac50fbac CR	29	#if HAVE_LANGINFO_CODESET
	30	# include <langinfo.h>
	31	#endif
	32
ccc6cda3 JA	33	#include "bashintl.h"
	34	#include "bashansi.h"
	35	#include <stdio.h>
f73dda09	36	#include "chartypes.h"
3185942a	37	#include <errno.h>
ccc6cda3 JA	38
ccc6cda3 JA	39	#include "shell.h"
7117c2d2 JA	40	#include "input.h" /* For bash_input */
7117c2d2 JA	41
3185942a JA	42	#ifndef errno
	43	extern int errno;
	44	#endif
	45
d233b485	46	int locale_utf8locale;
ac50fbac	47	int locale_mb_cur_max; /* value of MB_CUR_MAX for current locale (LC_CTYPE) */
d233b485	48	int locale_shiftstates;
ac50fbac	49
7117c2d2	50	extern int dump_translatable_strings, dump_po_strings;
ccc6cda3 JA	51
	52	/* The current locale when the program begins */
	53	static char *default_locale;
	54
	55	/* The current domain for textdomain(3). */
	56	static char *default_domain;
	57	static char *default_dir;
	58
	59	/* tracks the value of LC_ALL; used to override values for other locale
	60	categories */
	61	static char *lc_all;
	62
b80f6443 JA	63	/* tracks the value of LC_ALL; used to provide defaults for locale
	64	categories */
	65	static char *lang;
	66
	67	/* Called to reset all of the locale variables to their appropriate values
	68	if (and only if) LC_ALL has not been assigned a value. */
	69	static int reset_locale_vars __P((void));
	70
	71	static void locale_setblanks __P((void));
ac50fbac	72	static int locale_isutf8 __P((char *));
b80f6443	73
ccc6cda3 JA	74	/* Set the value of default_locale and make the current locale the
	75	system default locale. This should be called very early in main(). */
	76	void
	77	set_default_locale ()
	78	{
	79	#if defined (HAVE_SETLOCALE)
	80	default_locale = setlocale (LC_ALL, "");
	81	if (default_locale)
	82	default_locale = savestring (default_locale);
	83	#endif /* HAVE_SETLOCALE */
b80f6443 JA	84	bindtextdomain (PACKAGE, LOCALEDIR);
b80f6443 JA	85	textdomain (PACKAGE);
ac50fbac CR	86
ac50fbac CR	87	locale_mb_cur_max = MB_CUR_MAX;
d233b485 CR	88	locale_utf8locale = locale_isutf8 (default_locale);
d233b485 CR	89	locale_shiftstates = mblen ((char *)NULL, 0);
ccc6cda3 JA	90	}
ccc6cda3 JA	91
95732b49 JA	92	/* Set default values for LC_CTYPE, LC_COLLATE, LC_MESSAGES, LC_NUMERIC and
95732b49 JA	93	LC_TIME if they are not specified in the environment, but LC_ALL is. This
ccc6cda3 JA	94	should be called from main() after parsing the environment. */
	95	void
	96	set_default_locale_vars ()
	97	{
	98	char *val;
	99
	100	#if defined (HAVE_SETLOCALE)
b80f6443 JA	101
b80f6443 JA	102	# if defined (LC_CTYPE)
ccc6cda3 JA	103	val = get_string_value ("LC_CTYPE");
ccc6cda3 JA	104	if (val == 0 && lc_all && *lc_all)
b80f6443 JA	105	{
	106	setlocale (LC_CTYPE, lc_all);
	107	locale_setblanks ();
ac50fbac	108	locale_mb_cur_max = MB_CUR_MAX;
d233b485 CR	109	locale_utf8locale = locale_isutf8 (lc_all);
d233b485 CR	110	locale_shiftstates = mblen ((char *)NULL, 0);
ac50fbac	111	u32reset ();
b80f6443 JA	112	}
b80f6443 JA	113	# endif
ccc6cda3 JA	114
	115	# if defined (LC_COLLATE)
	116	val = get_string_value ("LC_COLLATE");
	117	if (val == 0 && lc_all && *lc_all)
	118	setlocale (LC_COLLATE, lc_all);
	119	# endif /* LC_COLLATE */
	120
	121	# if defined (LC_MESSAGES)
	122	val = get_string_value ("LC_MESSAGES");
	123	if (val == 0 && lc_all && *lc_all)
	124	setlocale (LC_MESSAGES, lc_all);
	125	# endif /* LC_MESSAGES */
	126
bb70624e JA	127	# if defined (LC_NUMERIC)
	128	val = get_string_value ("LC_NUMERIC");
	129	if (val == 0 && lc_all && *lc_all)
	130	setlocale (LC_NUMERIC, lc_all);
	131	# endif /* LC_NUMERIC */
	132
95732b49 JA	133	# if defined (LC_TIME)
	134	val = get_string_value ("LC_TIME");
	135	if (val == 0 && lc_all && *lc_all)
	136	setlocale (LC_TIME, lc_all);
	137	# endif /* LC_TIME */
	138
ccc6cda3 JA	139	#endif /* HAVE_SETLOCALE */
	140
	141	val = get_string_value ("TEXTDOMAIN");
	142	if (val && *val)
	143	{
	144	FREE (default_domain);
	145	default_domain = savestring (val);
ac50fbac CR	146	if (default_dir && *default_dir)
ac50fbac CR	147	bindtextdomain (default_domain, default_dir);
ccc6cda3 JA	148	}
	149
	150	val = get_string_value ("TEXTDOMAINDIR");
	151	if (val && *val)
	152	{
	153	FREE (default_dir);
	154	default_dir = savestring (val);
b80f6443 JA	155	if (default_domain && *default_domain)
b80f6443 JA	156	bindtextdomain (default_domain, default_dir);
ccc6cda3 JA	157	}
	158	}
	159
	160	/* Set one of the locale categories (specified by VAR) to VALUE. Returns 1
	161	if successful, 0 otherwise. */
	162	int
	163	set_locale_var (var, value)
	164	char var, value;
	165	{
b80f6443	166	int r;
3185942a	167	char *x;
b80f6443	168
3185942a JA	169	x = "";
3185942a JA	170	errno = 0;
ccc6cda3 JA	171	if (var[0] == 'T' && var[10] == 0) /* TEXTDOMAIN */
	172	{
	173	FREE (default_domain);
	174	default_domain = value ? savestring (value) : (char *)NULL;
ac50fbac CR	175	if (default_dir && *default_dir)
ac50fbac CR	176	bindtextdomain (default_domain, default_dir);
ccc6cda3 JA	177	return (1);
	178	}
	179	else if (var[0] == 'T') /* TEXTDOMAINDIR */
	180	{
	181	FREE (default_dir);
	182	default_dir = value ? savestring (value) : (char *)NULL;
b80f6443 JA	183	if (default_domain && *default_domain)
b80f6443 JA	184	bindtextdomain (default_domain, default_dir);
ccc6cda3 JA	185	return (1);
	186	}
	187
	188	/* var[0] == 'L' && var[1] == 'C' && var[2] == '_' */
	189
	190	else if (var[3] == 'A') /* LC_ALL */
	191	{
	192	FREE (lc_all);
e8ce775d JA	193	if (value)
e8ce775d JA	194	lc_all = savestring (value);
e8ce775d JA	195	else
e8ce775d JA	196	{
f73dda09	197	lc_all = (char *)xmalloc (1);
e8ce775d JA	198	lc_all[0] = '\0';
e8ce775d JA	199	}
ccc6cda3	200	#if defined (HAVE_SETLOCALE)
3185942a JA	201	r = *lc_all ? ((x = setlocale (LC_ALL, lc_all)) != 0) : reset_locale_vars ();
3185942a JA	202	if (x == 0)
17345e5a JA	203	{
	204	if (errno == 0)
	205	internal_warning(_("setlocale: LC_ALL: cannot change locale (%s)"), lc_all);
	206	else
	207	internal_warning(_("setlocale: LC_ALL: cannot change locale (%s): %s"), lc_all, strerror (errno));
	208	}
b80f6443	209	locale_setblanks ();
ac50fbac	210	locale_mb_cur_max = MB_CUR_MAX;
d233b485 CR	211	/* if LC_ALL == "", reset_locale_vars has already called this */
	212	if (*lc_all && x)
	213	locale_utf8locale = locale_isutf8 (lc_all);
	214	locale_shiftstates = mblen ((char *)NULL, 0);
ac50fbac	215	u32reset ();
b80f6443	216	return r;
ccc6cda3 JA	217	#else
	218	return (1);
	219	#endif
	220	}
	221
	222	#if defined (HAVE_SETLOCALE)
	223	else if (var[3] == 'C' && var[4] == 'T') /* LC_CTYPE */
	224	{
b80f6443	225	# if defined (LC_CTYPE)
ccc6cda3	226	if (lc_all == 0 \|\| *lc_all == '\0')
b80f6443	227	{
3185942a	228	x = setlocale (LC_CTYPE, get_locale_var ("LC_CTYPE"));
b80f6443	229	locale_setblanks ();
ac50fbac	230	locale_mb_cur_max = MB_CUR_MAX;
d233b485 CR	231	/* if setlocale() returns NULL, the locale is not changed */
	232	if (x)
	233	locale_utf8locale = locale_isutf8 (x);
	234	locale_shiftstates = mblen ((char *)NULL, 0);
ac50fbac	235	u32reset ();
b80f6443 JA	236	}
b80f6443 JA	237	# endif
ccc6cda3 JA	238	}
	239	else if (var[3] == 'C' && var[4] == 'O') /* LC_COLLATE */
	240	{
	241	# if defined (LC_COLLATE)
	242	if (lc_all == 0 \|\| *lc_all == '\0')
3185942a	243	x = setlocale (LC_COLLATE, get_locale_var ("LC_COLLATE"));
ccc6cda3 JA	244	# endif /* LC_COLLATE */
	245	}
	246	else if (var[3] == 'M' && var[4] == 'E') /* LC_MESSAGES */
	247	{
	248	# if defined (LC_MESSAGES)
	249	if (lc_all == 0 \|\| *lc_all == '\0')
3185942a	250	x = setlocale (LC_MESSAGES, get_locale_var ("LC_MESSAGES"));
ccc6cda3 JA	251	# endif /* LC_MESSAGES */
ccc6cda3 JA	252	}
f73dda09	253	else if (var[3] == 'N' && var[4] == 'U') /* LC_NUMERIC */
bb70624e JA	254	{
	255	# if defined (LC_NUMERIC)
	256	if (lc_all == 0 \|\| *lc_all == '\0')
3185942a	257	x = setlocale (LC_NUMERIC, get_locale_var ("LC_NUMERIC"));
bb70624e JA	258	# endif /* LC_NUMERIC */
bb70624e JA	259	}
95732b49 JA	260	else if (var[3] == 'T' && var[4] == 'I') /* LC_TIME */
	261	{
	262	# if defined (LC_TIME)
	263	if (lc_all == 0 \|\| *lc_all == '\0')
3185942a	264	x = setlocale (LC_TIME, get_locale_var ("LC_TIME"));
95732b49 JA	265	# endif /* LC_TIME */
95732b49 JA	266	}
ccc6cda3	267	#endif /* HAVE_SETLOCALE */
95732b49	268
3185942a	269	if (x == 0)
17345e5a JA	270	{
	271	if (errno == 0)
	272	internal_warning(_("setlocale: %s: cannot change locale (%s)"), var, get_locale_var (var));
	273	else
	274	internal_warning(_("setlocale: %s: cannot change locale (%s): %s"), var, get_locale_var (var), strerror (errno));
	275	}
ccc6cda3	276
3185942a	277	return (x != 0);
ccc6cda3 JA	278	}
ccc6cda3 JA	279
b80f6443 JA	280	/* Called when LANG is assigned a value. Tracks value in `lang'. Calls
	281	reset_locale_vars() to reset any default values if LC_ALL is unset or
	282	null. */
ccc6cda3 JA	283	int
	284	set_lang (var, value)
	285	char var, value;
	286	{
b80f6443 JA	287	FREE (lang);
	288	if (value)
	289	lang = savestring (value);
	290	else
	291	{
	292	lang = (char *)xmalloc (1);
	293	lang[0] = '\0';
	294	}
ac50fbac	295
b80f6443	296	return ((lc_all == 0 \|\| *lc_all == 0) ? reset_locale_vars () : 0);
ccc6cda3 JA	297	}
ccc6cda3 JA	298
0628567a JA	299	/* Set default values for LANG and LC_ALL. Default values for all other
	300	locale-related variables depend on these. */
	301	void
	302	set_default_lang ()
	303	{
	304	char *v;
	305
	306	v = get_string_value ("LC_ALL");
	307	set_locale_var ("LC_ALL", v);
	308
	309	v = get_string_value ("LANG");
	310	set_lang ("LANG", v);
	311	}
	312
b80f6443 JA	313	/* Get the value of one of the locale variables (LC_MESSAGES, LC_CTYPE).
	314	The precedence is as POSIX.2 specifies: LC_ALL has precedence over
	315	the specific locale variables, and LANG, if set, is used as the default. */
ccc6cda3 JA	316	char *
	317	get_locale_var (var)
	318	char *var;
	319	{
	320	char *locale;
	321
	322	locale = lc_all;
	323
b80f6443	324	if (locale == 0 \|\| *locale == 0)
a0c0a00f	325	locale = get_string_value (var); /* XXX - no mem leak */
b80f6443 JA	326	if (locale == 0 \|\| *locale == 0)
	327	locale = lang;
	328	if (locale == 0 \|\| *locale == 0)
3185942a	329	#if 0
0628567a	330	locale = default_locale; /* system-dependent; not really portable. should it be "C"? */
3185942a JA	331	#else
	332	locale = "";
	333	#endif
ccc6cda3 JA	334	return (locale);
	335	}
	336
b80f6443 JA	337	/* Called to reset all of the locale variables to their appropriate values
	338	if (and only if) LC_ALL has not been assigned a value. DO NOT CALL THIS
	339	IF LC_ALL HAS BEEN ASSIGNED A VALUE. */
	340	static int
	341	reset_locale_vars ()
	342	{
d233b485	343	char t, x;
b80f6443	344	#if defined (HAVE_SETLOCALE)
0628567a JA	345	if (lang == 0 \|\| *lang == '\0')
	346	maybe_make_export_env (); /* trust that this will change environment for setlocale */
	347	if (setlocale (LC_ALL, lang ? lang : "") == 0)
b80f6443 JA	348	return 0;
b80f6443 JA	349
d233b485	350	x = 0;
b80f6443	351	# if defined (LC_CTYPE)
d233b485	352	x = setlocale (LC_CTYPE, get_locale_var ("LC_CTYPE"));
b80f6443 JA	353	# endif
b80f6443 JA	354	# if defined (LC_COLLATE)
3185942a	355	t = setlocale (LC_COLLATE, get_locale_var ("LC_COLLATE"));
b80f6443 JA	356	# endif
b80f6443 JA	357	# if defined (LC_MESSAGES)
3185942a	358	t = setlocale (LC_MESSAGES, get_locale_var ("LC_MESSAGES"));
b80f6443 JA	359	# endif
b80f6443 JA	360	# if defined (LC_NUMERIC)
3185942a	361	t = setlocale (LC_NUMERIC, get_locale_var ("LC_NUMERIC"));
b80f6443	362	# endif
95732b49	363	# if defined (LC_TIME)
3185942a	364	t = setlocale (LC_TIME, get_locale_var ("LC_TIME"));
95732b49	365	# endif
b80f6443 JA	366
b80f6443 JA	367	locale_setblanks ();
ac50fbac	368	locale_mb_cur_max = MB_CUR_MAX;
d233b485 CR	369	if (x)
	370	locale_utf8locale = locale_isutf8 (x);
	371	locale_shiftstates = mblen ((char *)NULL, 0);
ac50fbac	372	u32reset ();
b80f6443 JA	373	#endif
	374	return 1;
	375	}
	376
ccc6cda3 JA	377	/* Translate the contents of STRING, a $"..." quoted string, according
	378	to the current locale. In the `C' or `POSIX' locale, or if gettext()
	379	is not available, the passed string is returned unchanged. The
	380	length of the translated string is returned in LENP, if non-null. */
	381	char *
	382	localetrans (string, len, lenp)
	383	char *string;
	384	int len, *lenp;
	385	{
	386	char locale, t;
ccc6cda3 JA	387	char *translated;
ccc6cda3 JA	388	int tlen;
ccc6cda3 JA	389
	390	/* Don't try to translate null strings. */
	391	if (string == 0 \|\| *string == 0)
	392	{
	393	if (lenp)
28ef6c31	394	*lenp = 0;
ccc6cda3 JA	395	return ((char *)NULL);
	396	}
	397
ccc6cda3 JA	398	locale = get_locale_var ("LC_MESSAGES");
	399
	400	/* If we don't have setlocale() or the current locale is `C' or `POSIX',
	401	just return the string. If we don't have gettext(), there's no use
	402	doing anything else. */
ccc6cda3 JA	403	if (locale == 0 \|\| locale[0] == '\0' \|\|
ccc6cda3 JA	404	(locale[0] == 'C' && locale[1] == '\0') \|\| STREQ (locale, "POSIX"))
ccc6cda3	405	{
f73dda09	406	t = (char *)xmalloc (len + 1);
ccc6cda3 JA	407	strcpy (t, string);
	408	if (lenp)
	409	*lenp = len;
	410	return (t);
	411	}
	412
ccc6cda3	413	/* Now try to translate it. */
b80f6443 JA	414	if (default_domain && *default_domain)
	415	translated = dgettext (default_domain, string);
	416	else
	417	translated = string;
	418
ccc6cda3 JA	419	if (translated == string) /* gettext returns its argument if untranslatable */
ccc6cda3 JA	420	{
f73dda09	421	t = (char *)xmalloc (len + 1);
ccc6cda3 JA	422	strcpy (t, string);
	423	if (lenp)
	424	*lenp = len;
	425	}
	426	else
	427	{
ccc6cda3	428	tlen = strlen (translated);
f73dda09	429	t = (char *)xmalloc (tlen + 1);
ccc6cda3 JA	430	strcpy (t, translated);
	431	if (lenp)
	432	*lenp = tlen;
	433	}
	434	return (t);
ccc6cda3	435	}
7117c2d2 JA	436
	437	/* Change a bash string into a string suitable for inclusion in a `po' file.
	438	This backslash-escapes `"' and `\' and changes newlines into \\\n"\n". */
	439	char *
	440	mk_msgstr (string, foundnlp)
	441	char *string;
	442	int *foundnlp;
	443	{
	444	register int c, len;
	445	char result, r, *s;
	446
	447	for (len = 0, s = string; s && *s; s++)
	448	{
	449	len++;
	450	if (s == '"' \|\| s == '\\')
	451	len++;
	452	else if (*s == '\n')
	453	len += 5;
	454	}
	455
	456	r = result = (char *)xmalloc (len + 3);
	457	*r++ = '"';
	458
	459	for (s = string; s && (c = *s); s++)
	460	{
	461	if (c == '\n') /* <NL> -> \n"<NL>" */
	462	{
	463	*r++ = '\\';
	464	*r++ = 'n';
	465	*r++ = '"';
	466	*r++ = '\n';
	467	*r++ = '"';
	468	if (foundnlp)
	469	*foundnlp = 1;
	470	continue;
	471	}
	472	if (c == '"' \|\| c == '\\')
	473	*r++ = '\\';
	474	*r++ = c;
	475	}
	476
	477	*r++ = '"';
	478	*r++ = '\0';
	479
	480	return result;
	481	}
	482
	483	/* $"..." -- Translate the portion of STRING between START and END
	484	according to current locale using gettext (if available) and return
	485	the result. The caller will take care of leaving the quotes intact.
	486	The string will be left without the leading `$' by the caller.
	487	If translation is performed, the translated string will be double-quoted
	488	by the caller. The length of the translated string is returned in LENP,
	489	if non-null. */
	490	char *
	491	localeexpand (string, start, end, lineno, lenp)
	492	char *string;
	493	int start, end, lineno, *lenp;
	494	{
	495	int len, tlen, foundnl;
	496	char temp, t, *t2;
	497
	498	temp = (char *)xmalloc (end - start + 1);
	499	for (tlen = 0, len = start; len < end; )
500	temp[tlen++] = string[len++];
501	temp[tlen] = '\0';
502
503	/* If we're just dumping translatable strings, don't do anything with the
b80f6443 JA	504	string itself, but if we're dumping in `po' file format, convert it into
	505	a form more palatable to gettext(3) and friends by quoting `"' and `\'
	506	with backslashes and converting <NL> into `\n"<NL>"'. If we find a
	507	newline in TEMP, we first output a `msgid ""' line and then the
	508	translated string; otherwise we output the `msgid' and translated
	509	string all on one line. */
7117c2d2 JA	510	if (dump_translatable_strings)
	511	{
	512	if (dump_po_strings)
	513	{
	514	foundnl = 0;
	515	t = mk_msgstr (temp, &foundnl);
	516	t2 = foundnl ? "\"\"\n" : "";
	517
	518	printf ("#: %s:%d\nmsgid %s%s\nmsgstr \"\"\n",
	519	yy_input_name (), lineno, t2, t);
	520	free (t);
	521	}
	522	else
	523	printf ("\"%s\"\n", temp);
	524
	525	if (lenp)
	526	*lenp = tlen;
	527	return (temp);
	528	}
	529	else if (*temp)
	530	{
	531	t = localetrans (temp, tlen, &len);
	532	free (temp);
	533	if (lenp)
	534	*lenp = len;
	535	return (t);
	536	}
	537	else
	538	{
	539	if (lenp)
	540	*lenp = 0;
	541	return (temp);
	542	}
	543	}
b80f6443 JA	544
	545	/* Set every character in the <blank> character class to be a shell break
	546	character for the lexical analyzer when the locale changes. */
	547	static void
	548	locale_setblanks ()
	549	{
	550	int x;
	551
	552	for (x = 0; x < sh_syntabsiz; x++)
	553	{
a0c0a00f	554	if (isblank ((unsigned char)x))
0628567a	555	sh_syntaxtab[x] \|= CSHBRK\|CBLANK;
b80f6443	556	else if (member (x, shell_break_chars))
0628567a JA	557	{
	558	sh_syntaxtab[x] \|= CSHBRK;
	559	sh_syntaxtab[x] &= ~CBLANK;
	560	}
b80f6443	561	else
0628567a	562	sh_syntaxtab[x] &= ~(CSHBRK\|CBLANK);
b80f6443 JA	563	}
b80f6443 JA	564	}
ac50fbac	565
d233b485 CR	566	/* Parse a locale specification
	567	language[_territory][.codeset][@modifier][+special][,[sponsor][_revision]]
	568	and return TRUE if the codeset is UTF-8 or utf8 */
ac50fbac CR	569	static int
	570	locale_isutf8 (lspec)
	571	char *lspec;
	572	{
d233b485	573	char cp, encoding;
ac50fbac CR	574
	575	#if HAVE_LANGINFO_CODESET
	576	cp = nl_langinfo (CODESET);
	577	return (STREQ (cp, "UTF-8") \|\| STREQ (cp, "utf8"));
d233b485 CR	578	#elif HAVE_LOCALE_CHARSET
	579	cp = locale_charset ();
	580	return (STREQ (cp, "UTF-8") \|\| STREQ (cp, "utf8"));
ac50fbac CR	581	#else
ac50fbac CR	582	/* Take a shot */
d233b485 CR	583	for (cp = lspec; cp && cp != '@' && cp != '+' && cp != ','; cp++)
	584	{
	585	if (*cp == '.')
	586	{
	587	for (encoding = ++cp; cp && cp != '@' && cp != '+' && cp != ','; cp++)
	588	;
	589	/* The encoding (codeset) is the substring between encoding and cp */
	590	if ((cp - encoding == 5 && STREQN (encoding, "UTF-8", 5)) \|\|
	591	(cp - encoding == 4 && STREQN (encoding, "utf8", 4)))
	592	return 1;
	593	else
	594	return 0;
	595	}
	596	}
	597	return 0;
ac50fbac CR	598	#endif
ac50fbac CR	599	}
d233b485 CR	600
	601	#if defined (HAVE_LOCALECONV)
	602	int
	603	locale_decpoint ()
	604	{
	605	struct lconv *lv;
	606
	607	lv = localeconv ();
	608	return (lv && lv->decimal_point && lv->decimal_point[0]) ? lv->decimal_point[0] : '.';
	609	}
	610	#else
	611	# undef locale_decpoint
	612	int
	613	locale_decpoint ()
	614	{
	615	return '.';
	616	}
	617	#endif