locale.c

   1 /* locale.c - Miscellaneous internationalization functions. */
   2
   3 /* Copyright (C) 1996-2009,2012,2016 Free Software Foundation, Inc.
   4
   5    This file is part of GNU Bash, the Bourne Again SHell.
   6
   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.
  11
  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.
  16
  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 */
  20
  21 #include "config.h"
  22
  23 #include "bashtypes.h"
  24
  25 #if defined (HAVE_UNISTD_H)
  26 #  include <unistd.h>
  27 #endif
  28
  29 #if HAVE_LANGINFO_CODESET
  30 #  include <langinfo.h>
  31 #endif
  32
  33 #include "bashintl.h"
  34 #include "bashansi.h"
  35 #include <stdio.h>
  36 #include "chartypes.h"
  37 #include <errno.h>
  38
  39 #include "shell.h"
  40 #include "input.h"      /* For bash_input */
  41
  42 #ifndef errno
  43 extern int errno;
  44 #endif
  45
  46 int locale_utf8locale;
  47 int locale_mb_cur_max;  /* value of MB_CUR_MAX for current locale (LC_CTYPE) */
  48 int locale_shiftstates;
  49
  50 extern int dump_translatable_strings, dump_po_strings;
  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
  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));
  72 static int locale_isutf8 __P((char *));
  73
  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 */
  84   bindtextdomain (PACKAGE, LOCALEDIR);
  85   textdomain (PACKAGE);
  86
  87   locale_mb_cur_max = MB_CUR_MAX;
  88   locale_utf8locale = locale_isutf8 (default_locale);
  89   locale_shiftstates = mblen ((char *)NULL, 0);
  90 }
  91
  92 /* Set default values for LC_CTYPE, LC_COLLATE, LC_MESSAGES, LC_NUMERIC and
  93    LC_TIME if they are not specified in the environment, but LC_ALL is.  This
  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)
 101
 102 #  if defined (LC_CTYPE)
 103   val = get_string_value ("LC_CTYPE");
 104   if (val == 0 && lc_all && *lc_all)
 105     {
 106       setlocale (LC_CTYPE, lc_all);
 107       locale_setblanks ();
 108       locale_mb_cur_max = MB_CUR_MAX;
 109       locale_utf8locale = locale_isutf8 (lc_all);
 110       locale_shiftstates = mblen ((char *)NULL, 0);
 111       u32reset ();
 112     }
 113 #  endif
 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
 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
 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
 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);
 146       if (default_dir && *default_dir)
 147         bindtextdomain (default_domain, default_dir);
 148     }
 149
 150   val = get_string_value ("TEXTDOMAINDIR");
 151   if (val && *val)
 152     {
 153       FREE (default_dir);
 154       default_dir = savestring (val);
 155       if (default_domain && *default_domain)
 156         bindtextdomain (default_domain, default_dir);
 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 {
 166   int r;
 167   char *x;
 168
 169   x = "";
 170   errno = 0;
 171   if (var[0] == 'T' && var[10] == 0)            /* TEXTDOMAIN */
 172     {
 173       FREE (default_domain);
 174       default_domain = value ? savestring (value) : (char *)NULL;
 175       if (default_dir && *default_dir)
 176         bindtextdomain (default_domain, default_dir);
 177       return (1);
 178     }
 179   else if (var[0] == 'T')                       /* TEXTDOMAINDIR */
 180     {
 181       FREE (default_dir);
 182       default_dir = value ? savestring (value) : (char *)NULL;
 183       if (default_domain && *default_domain)
 184         bindtextdomain (default_domain, default_dir);
 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);
 193       if (value)
 194         lc_all = savestring (value);
 195       else
 196         {
 197           lc_all = (char *)xmalloc (1);
 198           lc_all[0] = '\0';
 199         }
 200 #if defined (HAVE_SETLOCALE)
 201       r = *lc_all ? ((x = setlocale (LC_ALL, lc_all)) != 0) : reset_locale_vars ();
 202       if (x == 0)
 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         }
 209       locale_setblanks ();
 210       locale_mb_cur_max = MB_CUR_MAX;
 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);
 215       u32reset ();
 216       return r;
 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     {
 225 #  if defined (LC_CTYPE)
 226       if (lc_all == 0 || *lc_all == '\0')
 227         {
 228           x = setlocale (LC_CTYPE, get_locale_var ("LC_CTYPE"));
 229           locale_setblanks ();
 230           locale_mb_cur_max = MB_CUR_MAX;
 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);
 235           u32reset ();
 236         }
 237 #  endif
 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')
 243         x = setlocale (LC_COLLATE, get_locale_var ("LC_COLLATE"));
 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')
 250         x = setlocale (LC_MESSAGES, get_locale_var ("LC_MESSAGES"));
 251 #  endif /* LC_MESSAGES */
 252     }
 253   else if (var[3] == 'N' && var[4] == 'U')      /* LC_NUMERIC */
 254     {
 255 #  if defined (LC_NUMERIC)
 256       if (lc_all == 0 || *lc_all == '\0')
 257         x = setlocale (LC_NUMERIC, get_locale_var ("LC_NUMERIC"));
 258 #  endif /* LC_NUMERIC */
 259     }
 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')
 264         x = setlocale (LC_TIME, get_locale_var ("LC_TIME"));
 265 #  endif /* LC_TIME */
 266     }
 267 #endif /* HAVE_SETLOCALE */
 268
 269   if (x == 0)
 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     }
 276
 277   return (x != 0);
 278 }
 279
 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. */
 283 int
 284 set_lang (var, value)
 285      char *var, *value;
 286 {
 287   FREE (lang);
 288   if (value)
 289     lang = savestring (value);
 290   else
 291     {
 292       lang = (char *)xmalloc (1);
 293       lang[0] = '\0';
 294     }
 295
 296   return ((lc_all == 0 || *lc_all == 0) ? reset_locale_vars () : 0);
 297 }
 298
 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
 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. */
 316 char *
 317 get_locale_var (var)
 318      char *var;
 319 {
 320   char *locale;
 321
 322   locale = lc_all;
 323
 324   if (locale == 0 || *locale == 0)
 325     locale = get_string_value (var);    /* XXX - no mem leak */
 326   if (locale == 0 || *locale == 0)
 327     locale = lang;
 328   if (locale == 0 || *locale == 0)
 329 #if 0
 330     locale = default_locale;    /* system-dependent; not really portable.  should it be "C"? */
 331 #else
 332     locale = "";
 333 #endif
 334   return (locale);
 335 }
 336
 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 {
 343   char *t, *x;
 344 #if defined (HAVE_SETLOCALE)
 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)
 348     return 0;
 349
 350   x = 0;
 351 #  if defined (LC_CTYPE)
 352   x = setlocale (LC_CTYPE, get_locale_var ("LC_CTYPE"));
 353 #  endif
 354 #  if defined (LC_COLLATE)
 355   t = setlocale (LC_COLLATE, get_locale_var ("LC_COLLATE"));
 356 #  endif
 357 #  if defined (LC_MESSAGES)
 358   t = setlocale (LC_MESSAGES, get_locale_var ("LC_MESSAGES"));
 359 #  endif
 360 #  if defined (LC_NUMERIC)
 361   t = setlocale (LC_NUMERIC, get_locale_var ("LC_NUMERIC"));
 362 #  endif
 363 #  if defined (LC_TIME)
 364   t = setlocale (LC_TIME, get_locale_var ("LC_TIME"));
 365 #  endif
 366
 367   locale_setblanks ();
 368   locale_mb_cur_max = MB_CUR_MAX;
 369   if (x)
 370     locale_utf8locale = locale_isutf8 (x);
 371   locale_shiftstates = mblen ((char *)NULL, 0);
 372   u32reset ();
 373 #endif
 374   return 1;
 375 }
 376
 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;
 387   char *translated;
 388   int tlen;
 389
 390   /* Don't try to translate null strings. */
 391   if (string == 0 || *string == 0)
 392     {
 393       if (lenp)
 394         *lenp = 0;
 395       return ((char *)NULL);
 396     }
 397
 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. */
 403   if (locale == 0 || locale[0] == '\0' ||
 404       (locale[0] == 'C' && locale[1] == '\0') || STREQ (locale, "POSIX"))
 405     {
 406       t = (char *)xmalloc (len + 1);
 407       strcpy (t, string);
 408       if (lenp)
 409         *lenp = len;
 410       return (t);
 411     }
 412
 413   /* Now try to translate it. */
 414   if (default_domain && *default_domain)
 415     translated = dgettext (default_domain, string);
 416   else
 417     translated = string;
 418
 419   if (translated == string)     /* gettext returns its argument if untranslatable */
 420     {
 421       t = (char *)xmalloc (len + 1);
 422       strcpy (t, string);
 423       if (lenp)
 424         *lenp = len;
 425     }
 426   else
 427     {
 428       tlen = strlen (translated);
 429       t = (char *)xmalloc (tlen + 1);
 430       strcpy (t, translated);
 431       if (lenp)
 432         *lenp = tlen;
 433     }
 434   return (t);
 435 }
 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
 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. */
 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 }
 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     {
 554       if (isblank ((unsigned char)x))
 555         sh_syntaxtab[x] |= CSHBRK|CBLANK;
 556       else if (member (x, shell_break_chars))
 557         {
 558           sh_syntaxtab[x] |= CSHBRK;
 559           sh_syntaxtab[x] &= ~CBLANK;
 560         }
 561       else
 562         sh_syntaxtab[x] &= ~(CSHBRK|CBLANK);
 563     }
 564 }
 565
 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 */
 569 static int
 570 locale_isutf8 (lspec)
 571      char *lspec;
 572 {
 573   char *cp, *encoding;
 574
 575 #if HAVE_LANGINFO_CODESET
 576   cp = nl_langinfo (CODESET);
 577   return (STREQ (cp, "UTF-8") || STREQ (cp, "utf8"));
 578 #elif HAVE_LOCALE_CHARSET
 579   cp = locale_charset ();
 580   return (STREQ (cp, "UTF-8") || STREQ (cp, "utf8"));
 581 #else
 582   /* Take a shot */
 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;
 598 #endif
 599 }
 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