dcigettext.c revision 1.1
1 /* Implementation of the internal dcigettext function. 2 Copyright (C) 1995-1999, 2000-2006 Free Software Foundation, Inc. 3 4 This program is free software; you can redistribute it and/or modify it 5 under the terms of the GNU Library General Public License as published 6 by 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 GNU 12 Library General Public License for more details. 13 14 You should have received a copy of the GNU Library General Public 15 License along with this program; if not, write to the Free Software 16 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 17 USA. */ 18 19 /* Tell glibc's <string.h> to provide a prototype for mempcpy(). 20 This must come before <config.h> because <config.h> may include 21 <features.h>, and once <features.h> has been included, it's too late. */ 22 #ifndef _GNU_SOURCE 23 # define _GNU_SOURCE 1 24 #endif 25 26 #ifdef HAVE_CONFIG_H 27 # include <config.h> 28 #endif 29 30 /* NL_LOCALE_NAME does not work in glibc-2.4. Ignore it. */ 31 #undef HAVE_NL_LOCALE_NAME 32 33 #include <sys/types.h> 34 35 #ifdef __GNUC__ 36 # define alloca __builtin_alloca 37 # define HAVE_ALLOCA 1 38 #else 39 # ifdef _MSC_VER 40 # include <malloc.h> 41 # define alloca _alloca 42 # else 43 # if defined HAVE_ALLOCA_H || defined _LIBC 44 # include <alloca.h> 45 # else 46 # ifdef _AIX 47 #pragma alloca 48 # else 49 # ifndef alloca 50 char *alloca (); 51 # endif 52 # endif 53 # endif 54 # endif 55 #endif 56 57 #include <errno.h> 58 #ifndef errno 59 extern int errno; 60 #endif 61 #ifndef __set_errno 62 # define __set_errno(val) errno = (val) 63 #endif 64 65 #include <stddef.h> 66 #include <stdlib.h> 67 #include <string.h> 68 69 #if defined HAVE_UNISTD_H || defined _LIBC 70 # include <unistd.h> 71 #endif 72 73 #include <locale.h> 74 75 #ifdef _LIBC 76 /* Guess whether integer division by zero raises signal SIGFPE. 77 Set to 1 only if you know for sure. In case of doubt, set to 0. */ 78 # if defined __alpha__ || defined __arm__ || defined __i386__ \ 79 || defined __m68k__ || defined __s390__ 80 # define INTDIV0_RAISES_SIGFPE 1 81 # else 82 # define INTDIV0_RAISES_SIGFPE 0 83 # endif 84 #endif 85 #if !INTDIV0_RAISES_SIGFPE 86 # include <signal.h> 87 #endif 88 89 #if defined HAVE_SYS_PARAM_H || defined _LIBC 90 # include <sys/param.h> 91 #endif 92 93 #if !defined _LIBC && HAVE_NL_LOCALE_NAME 94 # include <langinfo.h> 95 #endif 96 97 #include "gettextP.h" 98 #include "plural-exp.h" 99 #ifdef _LIBC 100 # include <libintl.h> 101 #else 102 # ifdef IN_LIBGLOCALE 103 # include <libintl.h> 104 # endif 105 # include "libgnuintl.h" 106 #endif 107 #include "hash-string.h" 108 109 /* Handle multi-threaded applications. */ 110 #ifdef _LIBC 111 # include <bits/libc-lock.h> 112 # define gl_rwlock_define_initialized __libc_rwlock_define_initialized 113 # define gl_rwlock_rdlock __libc_rwlock_rdlock 114 # define gl_rwlock_wrlock __libc_rwlock_wrlock 115 # define gl_rwlock_unlock __libc_rwlock_unlock 116 #else 117 # include "lock.h" 118 #endif 119 120 /* Alignment of types. */ 121 #if defined __GNUC__ && __GNUC__ >= 2 122 # define alignof(TYPE) __alignof__ (TYPE) 123 #else 124 # define alignof(TYPE) \ 125 ((int) &((struct { char dummy1; TYPE dummy2; } *) 0)->dummy2) 126 #endif 127 128 /* The internal variables in the standalone libintl.a must have different 129 names than the internal variables in GNU libc, otherwise programs 130 using libintl.a cannot be linked statically. */ 131 #if !defined _LIBC 132 # define _nl_default_default_domain libintl_nl_default_default_domain 133 # define _nl_current_default_domain libintl_nl_current_default_domain 134 # define _nl_default_dirname libintl_nl_default_dirname 135 # define _nl_domain_bindings libintl_nl_domain_bindings 136 #endif 137 138 /* Some compilers, like SunOS4 cc, don't have offsetof in <stddef.h>. */ 139 #ifndef offsetof 140 # define offsetof(type,ident) ((size_t)&(((type*)0)->ident)) 141 #endif 142 143 /* @@ end of prolog @@ */ 144 145 #ifdef _LIBC 146 /* Rename the non ANSI C functions. This is required by the standard 147 because some ANSI C functions will require linking with this object 148 file and the name space must not be polluted. */ 149 # define getcwd __getcwd 150 # ifndef stpcpy 151 # define stpcpy __stpcpy 152 # endif 153 # define tfind __tfind 154 #else 155 # if !defined HAVE_GETCWD 156 char *getwd (); 157 # define getcwd(buf, max) getwd (buf) 158 # else 159 # if VMS 160 # define getcwd(buf, max) (getcwd) (buf, max, 0) 161 # else 162 char *getcwd (); 163 # endif 164 # endif 165 # ifndef HAVE_STPCPY 166 static char *stpcpy (char *dest, const char *src); 167 # endif 168 # ifndef HAVE_MEMPCPY 169 static void *mempcpy (void *dest, const void *src, size_t n); 170 # endif 171 #endif 172 173 /* Amount to increase buffer size by in each try. */ 174 #define PATH_INCR 32 175 176 /* The following is from pathmax.h. */ 177 /* Non-POSIX BSD systems might have gcc's limits.h, which doesn't define 178 PATH_MAX but might cause redefinition warnings when sys/param.h is 179 later included (as on MORE/BSD 4.3). */ 180 #if defined _POSIX_VERSION || (defined HAVE_LIMITS_H && !defined __GNUC__) 181 # include <limits.h> 182 #endif 183 184 #ifndef _POSIX_PATH_MAX 185 # define _POSIX_PATH_MAX 255 186 #endif 187 188 #if !defined PATH_MAX && defined _PC_PATH_MAX 189 # define PATH_MAX (pathconf ("/", _PC_PATH_MAX) < 1 ? 1024 : pathconf ("/", _PC_PATH_MAX)) 190 #endif 191 192 /* Don't include sys/param.h if it already has been. */ 193 #if defined HAVE_SYS_PARAM_H && !defined PATH_MAX && !defined MAXPATHLEN 194 # include <sys/param.h> 195 #endif 196 197 #if !defined PATH_MAX && defined MAXPATHLEN 198 # define PATH_MAX MAXPATHLEN 199 #endif 200 201 #ifndef PATH_MAX 202 # define PATH_MAX _POSIX_PATH_MAX 203 #endif 204 205 /* Pathname support. 206 ISSLASH(C) tests whether C is a directory separator character. 207 IS_ABSOLUTE_PATH(P) tests whether P is an absolute path. If it is not, 208 it may be concatenated to a directory pathname. 209 IS_PATH_WITH_DIR(P) tests whether P contains a directory specification. 210 */ 211 #if defined _WIN32 || defined __WIN32__ || defined __CYGWIN__ || defined __EMX__ || defined __DJGPP__ 212 /* Win32, Cygwin, OS/2, DOS */ 213 # define ISSLASH(C) ((C) == '/' || (C) == '\\') 214 # define HAS_DEVICE(P) \ 215 ((((P)[0] >= 'A' && (P)[0] <= 'Z') || ((P)[0] >= 'a' && (P)[0] <= 'z')) \ 216 && (P)[1] == ':') 217 # define IS_ABSOLUTE_PATH(P) (ISSLASH ((P)[0]) || HAS_DEVICE (P)) 218 # define IS_PATH_WITH_DIR(P) \ 219 (strchr (P, '/') != NULL || strchr (P, '\\') != NULL || HAS_DEVICE (P)) 220 #else 221 /* Unix */ 222 # define ISSLASH(C) ((C) == '/') 223 # define IS_ABSOLUTE_PATH(P) ISSLASH ((P)[0]) 224 # define IS_PATH_WITH_DIR(P) (strchr (P, '/') != NULL) 225 #endif 226 227 /* Whether to support different locales in different threads. */ 228 #if defined _LIBC || HAVE_NL_LOCALE_NAME || (HAVE_STRUCT___LOCALE_STRUCT___NAMES && defined USE_IN_GETTEXT_TESTS) || defined IN_LIBGLOCALE 229 # define HAVE_PER_THREAD_LOCALE 230 #endif 231 232 /* This is the type used for the search tree where known translations 233 are stored. */ 234 struct known_translation_t 235 { 236 /* Domain in which to search. */ 237 const char *domainname; 238 239 /* The category. */ 240 int category; 241 242 #ifdef HAVE_PER_THREAD_LOCALE 243 /* Name of the relevant locale category, or "" for the global locale. */ 244 const char *localename; 245 #endif 246 247 #ifdef IN_LIBGLOCALE 248 /* The character encoding. */ 249 const char *encoding; 250 #endif 251 252 /* State of the catalog counter at the point the string was found. */ 253 int counter; 254 255 /* Catalog where the string was found. */ 256 struct loaded_l10nfile *domain; 257 258 /* And finally the translation. */ 259 const char *translation; 260 size_t translation_length; 261 262 /* Pointer to the string in question. */ 263 char msgid[ZERO]; 264 }; 265 266 /* Root of the search tree with known translations. We can use this 267 only if the system provides the `tsearch' function family. */ 268 #if defined HAVE_TSEARCH || defined _LIBC 269 # include <search.h> 270 271 gl_rwlock_define_initialized (static, tree_lock) 272 273 static void *root; 274 275 # ifdef _LIBC 276 # define tsearch __tsearch 277 # endif 278 279 /* Function to compare two entries in the table of known translations. */ 280 static int 281 transcmp (const void *p1, const void *p2) 282 { 283 const struct known_translation_t *s1; 284 const struct known_translation_t *s2; 285 int result; 286 287 s1 = (const struct known_translation_t *) p1; 288 s2 = (const struct known_translation_t *) p2; 289 290 result = strcmp (s1->msgid, s2->msgid); 291 if (result == 0) 292 { 293 result = strcmp (s1->domainname, s2->domainname); 294 if (result == 0) 295 { 296 #ifdef HAVE_PER_THREAD_LOCALE 297 result = strcmp (s1->localename, s2->localename); 298 if (result == 0) 299 #endif 300 { 301 #ifdef IN_LIBGLOCALE 302 result = strcmp (s1->encoding, s2->encoding); 303 if (result == 0) 304 #endif 305 /* We compare the category last (though this is the cheapest 306 operation) since it is hopefully always the same (namely 307 LC_MESSAGES). */ 308 result = s1->category - s2->category; 309 } 310 } 311 } 312 313 return result; 314 } 315 #endif 316 317 /* Name of the default domain used for gettext(3) prior any call to 318 textdomain(3). The default value for this is "messages". */ 319 const char _nl_default_default_domain[] attribute_hidden = "messages"; 320 321 #ifndef IN_LIBGLOCALE 322 /* Value used as the default domain for gettext(3). */ 323 const char *_nl_current_default_domain attribute_hidden 324 = _nl_default_default_domain; 325 #endif 326 327 /* Contains the default location of the message catalogs. */ 328 #if defined __EMX__ 329 extern const char _nl_default_dirname[]; 330 #else 331 # ifdef _LIBC 332 extern const char _nl_default_dirname[]; 333 libc_hidden_proto (_nl_default_dirname) 334 # endif 335 const char _nl_default_dirname[] = LOCALEDIR; 336 # ifdef _LIBC 337 libc_hidden_data_def (_nl_default_dirname) 338 # endif 339 #endif 340 341 #ifndef IN_LIBGLOCALE 342 /* List with bindings of specific domains created by bindtextdomain() 343 calls. */ 344 struct binding *_nl_domain_bindings; 345 #endif 346 347 /* Prototypes for local functions. */ 348 static char *plural_lookup (struct loaded_l10nfile *domain, 349 unsigned long int n, 350 const char *translation, size_t translation_len) 351 internal_function; 352 353 #ifdef IN_LIBGLOCALE 354 static const char *guess_category_value (int category, 355 const char *categoryname, 356 const char *localename) 357 internal_function; 358 #else 359 static const char *guess_category_value (int category, 360 const char *categoryname) 361 internal_function; 362 #endif 363 364 #ifdef _LIBC 365 # include "../locale/localeinfo.h" 366 # define category_to_name(category) \ 367 _nl_category_names.str + _nl_category_name_idxs[category] 368 #else 369 static const char *category_to_name (int category) internal_function; 370 #endif 371 #if (defined _LIBC || HAVE_ICONV) && !defined IN_LIBGLOCALE 372 static const char *get_output_charset (struct binding *domainbinding) 373 internal_function; 374 #endif 375 376 377 /* For those loosing systems which don't have `alloca' we have to add 378 some additional code emulating it. */ 379 #ifdef HAVE_ALLOCA 380 /* Nothing has to be done. */ 381 # define freea(p) /* nothing */ 382 # define ADD_BLOCK(list, address) /* nothing */ 383 # define FREE_BLOCKS(list) /* nothing */ 384 #else 385 struct block_list 386 { 387 void *address; 388 struct block_list *next; 389 }; 390 # define ADD_BLOCK(list, addr) \ 391 do { \ 392 struct block_list *newp = (struct block_list *) malloc (sizeof (*newp)); \ 393 /* If we cannot get a free block we cannot add the new element to \ 394 the list. */ \ 395 if (newp != NULL) { \ 396 newp->address = (addr); \ 397 newp->next = (list); \ 398 (list) = newp; \ 399 } \ 400 } while (0) 401 # define FREE_BLOCKS(list) \ 402 do { \ 403 while (list != NULL) { \ 404 struct block_list *old = list; \ 405 list = list->next; \ 406 free (old->address); \ 407 free (old); \ 408 } \ 409 } while (0) 410 # undef alloca 411 # define alloca(size) (malloc (size)) 412 # define freea(p) free (p) 413 #endif /* have alloca */ 414 415 416 #ifdef _LIBC 417 /* List of blocks allocated for translations. */ 418 typedef struct transmem_list 419 { 420 struct transmem_list *next; 421 char data[ZERO]; 422 } transmem_block_t; 423 static struct transmem_list *transmem_list; 424 #else 425 typedef unsigned char transmem_block_t; 426 #endif 427 428 429 /* Names for the libintl functions are a problem. They must not clash 430 with existing names and they should follow ANSI C. But this source 431 code is also used in GNU C Library where the names have a __ 432 prefix. So we have to make a difference here. */ 433 #ifdef _LIBC 434 # define DCIGETTEXT __dcigettext 435 #else 436 # define DCIGETTEXT libintl_dcigettext 437 #endif 438 439 /* Lock variable to protect the global data in the gettext implementation. */ 440 gl_rwlock_define_initialized (, _nl_state_lock attribute_hidden) 441 442 /* Checking whether the binaries runs SUID must be done and glibc provides 443 easier methods therefore we make a difference here. */ 444 #ifdef _LIBC 445 # define ENABLE_SECURE __libc_enable_secure 446 # define DETERMINE_SECURE 447 #else 448 # ifndef HAVE_GETUID 449 # define getuid() 0 450 # endif 451 # ifndef HAVE_GETGID 452 # define getgid() 0 453 # endif 454 # ifndef HAVE_GETEUID 455 # define geteuid() getuid() 456 # endif 457 # ifndef HAVE_GETEGID 458 # define getegid() getgid() 459 # endif 460 static int enable_secure; 461 # define ENABLE_SECURE (enable_secure == 1) 462 # define DETERMINE_SECURE \ 463 if (enable_secure == 0) \ 464 { \ 465 if (getuid () != geteuid () || getgid () != getegid ()) \ 466 enable_secure = 1; \ 467 else \ 468 enable_secure = -1; \ 469 } 470 #endif 471 472 /* Get the function to evaluate the plural expression. */ 473 #include "eval-plural.h" 474 475 /* Look up MSGID in the DOMAINNAME message catalog for the current 476 CATEGORY locale and, if PLURAL is nonzero, search over string 477 depending on the plural form determined by N. */ 478 #ifdef IN_LIBGLOCALE 479 char * 480 gl_dcigettext (const char *domainname, 481 const char *msgid1, const char *msgid2, 482 int plural, unsigned long int n, 483 int category, 484 const char *localename, const char *encoding) 485 #else 486 char * 487 DCIGETTEXT (const char *domainname, const char *msgid1, const char *msgid2, 488 int plural, unsigned long int n, int category) 489 #endif 490 { 491 #ifndef HAVE_ALLOCA 492 struct block_list *block_list = NULL; 493 #endif 494 struct loaded_l10nfile *domain; 495 struct binding *binding; 496 const char *categoryname; 497 const char *categoryvalue; 498 const char *dirname; 499 char *xdomainname; 500 char *single_locale; 501 char *retval; 502 size_t retlen; 503 int saved_errno; 504 #if defined HAVE_TSEARCH || defined _LIBC 505 struct known_translation_t *search; 506 struct known_translation_t **foundp = NULL; 507 size_t msgid_len; 508 # if defined HAVE_PER_THREAD_LOCALE && !defined IN_LIBGLOCALE 509 const char *localename; 510 # endif 511 #endif 512 size_t domainname_len; 513 514 /* If no real MSGID is given return NULL. */ 515 if (msgid1 == NULL) 516 return NULL; 517 518 #ifdef _LIBC 519 if (category < 0 || category >= __LC_LAST || category == LC_ALL) 520 /* Bogus. */ 521 return (plural == 0 522 ? (char *) msgid1 523 /* Use the Germanic plural rule. */ 524 : n == 1 ? (char *) msgid1 : (char *) msgid2); 525 #endif 526 527 gl_rwlock_rdlock (_nl_state_lock); 528 529 /* If DOMAINNAME is NULL, we are interested in the default domain. If 530 CATEGORY is not LC_MESSAGES this might not make much sense but the 531 definition left this undefined. */ 532 if (domainname == NULL) 533 domainname = _nl_current_default_domain; 534 535 /* OS/2 specific: backward compatibility with older libintl versions */ 536 #ifdef LC_MESSAGES_COMPAT 537 if (category == LC_MESSAGES_COMPAT) 538 category = LC_MESSAGES; 539 #endif 540 541 #if defined HAVE_TSEARCH || defined _LIBC 542 msgid_len = strlen (msgid1) + 1; 543 544 /* Try to find the translation among those which we found at 545 some time. */ 546 search = (struct known_translation_t *) 547 alloca (offsetof (struct known_translation_t, msgid) + msgid_len); 548 memcpy (search->msgid, msgid1, msgid_len); 549 search->domainname = domainname; 550 search->category = category; 551 # ifdef HAVE_PER_THREAD_LOCALE 552 # ifndef IN_LIBGLOCALE 553 # ifdef _LIBC 554 localename = __current_locale_name (category); 555 # else 556 # if HAVE_NL_LOCALE_NAME 557 /* NL_LOCALE_NAME is public glibc API introduced in glibc-2.4. */ 558 localename = nl_langinfo (NL_LOCALE_NAME (category)); 559 # else 560 # if HAVE_STRUCT___LOCALE_STRUCT___NAMES && defined USE_IN_GETTEXT_TESTS 561 /* The __names field is not public glibc API and must therefore not be used 562 in code that is installed in public locations. */ 563 { 564 locale_t thread_locale = uselocale (NULL); 565 if (thread_locale != LC_GLOBAL_LOCALE) 566 localename = thread_locale->__names[category]; 567 else 568 localename = ""; 569 } 570 # endif 571 # endif 572 # endif 573 # endif 574 search->localename = localename; 575 # ifdef IN_LIBGLOCALE 576 search->encoding = encoding; 577 # endif 578 # endif 579 580 /* Since tfind/tsearch manage a balanced tree, concurrent tfind and 581 tsearch calls can be fatal. */ 582 gl_rwlock_rdlock (tree_lock); 583 584 foundp = (struct known_translation_t **) tfind (search, &root, transcmp); 585 586 gl_rwlock_unlock (tree_lock); 587 588 freea (search); 589 if (foundp != NULL && (*foundp)->counter == _nl_msg_cat_cntr) 590 { 591 /* Now deal with plural. */ 592 if (plural) 593 retval = plural_lookup ((*foundp)->domain, n, (*foundp)->translation, 594 (*foundp)->translation_length); 595 else 596 retval = (char *) (*foundp)->translation; 597 598 gl_rwlock_unlock (_nl_state_lock); 599 return retval; 600 } 601 #endif 602 603 /* Preserve the `errno' value. */ 604 saved_errno = errno; 605 606 /* See whether this is a SUID binary or not. */ 607 DETERMINE_SECURE; 608 609 /* First find matching binding. */ 610 #ifdef IN_LIBGLOCALE 611 /* We can use a trivial binding, since _nl_find_msg will ignore it anyway, 612 and _nl_load_domain and _nl_find_domain just pass it through. */ 613 binding = NULL; 614 dirname = bindtextdomain (domainname, NULL); 615 #else 616 for (binding = _nl_domain_bindings; binding != NULL; binding = binding->next) 617 { 618 int compare = strcmp (domainname, binding->domainname); 619 if (compare == 0) 620 /* We found it! */ 621 break; 622 if (compare < 0) 623 { 624 /* It is not in the list. */ 625 binding = NULL; 626 break; 627 } 628 } 629 630 if (binding == NULL) 631 dirname = _nl_default_dirname; 632 else 633 { 634 dirname = binding->dirname; 635 #endif 636 if (!IS_ABSOLUTE_PATH (dirname)) 637 { 638 /* We have a relative path. Make it absolute now. */ 639 size_t dirname_len = strlen (dirname) + 1; 640 size_t path_max; 641 char *resolved_dirname; 642 char *ret; 643 644 path_max = (unsigned int) PATH_MAX; 645 path_max += 2; /* The getcwd docs say to do this. */ 646 647 for (;;) 648 { 649 resolved_dirname = (char *) alloca (path_max + dirname_len); 650 ADD_BLOCK (block_list, tmp_dirname); 651 652 __set_errno (0); 653 ret = getcwd (resolved_dirname, path_max); 654 if (ret != NULL || errno != ERANGE) 655 break; 656 657 path_max += path_max / 2; 658 path_max += PATH_INCR; 659 } 660 661 if (ret == NULL) 662 /* We cannot get the current working directory. Don't signal an 663 error but simply return the default string. */ 664 goto return_untranslated; 665 666 stpcpy (stpcpy (strchr (resolved_dirname, '\0'), "/"), dirname); 667 dirname = resolved_dirname; 668 } 669 #ifndef IN_LIBGLOCALE 670 } 671 #endif 672 673 /* Now determine the symbolic name of CATEGORY and its value. */ 674 categoryname = category_to_name (category); 675 #ifdef IN_LIBGLOCALE 676 categoryvalue = guess_category_value (category, categoryname, localename); 677 #else 678 categoryvalue = guess_category_value (category, categoryname); 679 #endif 680 681 domainname_len = strlen (domainname); 682 xdomainname = (char *) alloca (strlen (categoryname) 683 + domainname_len + 5); 684 ADD_BLOCK (block_list, xdomainname); 685 686 stpcpy (mempcpy (stpcpy (stpcpy (xdomainname, categoryname), "/"), 687 domainname, domainname_len), 688 ".mo"); 689 690 /* Creating working area. */ 691 single_locale = (char *) alloca (strlen (categoryvalue) + 1); 692 ADD_BLOCK (block_list, single_locale); 693 694 695 /* Search for the given string. This is a loop because we perhaps 696 got an ordered list of languages to consider for the translation. */ 697 while (1) 698 { 699 /* Make CATEGORYVALUE point to the next element of the list. */ 700 while (categoryvalue[0] != '\0' && categoryvalue[0] == ':') 701 ++categoryvalue; 702 if (categoryvalue[0] == '\0') 703 { 704 /* The whole contents of CATEGORYVALUE has been searched but 705 no valid entry has been found. We solve this situation 706 by implicitly appending a "C" entry, i.e. no translation 707 will take place. */ 708 single_locale[0] = 'C'; 709 single_locale[1] = '\0'; 710 } 711 else 712 { 713 char *cp = single_locale; 714 while (categoryvalue[0] != '\0' && categoryvalue[0] != ':') 715 *cp++ = *categoryvalue++; 716 *cp = '\0'; 717 718 /* When this is a SUID binary we must not allow accessing files 719 outside the dedicated directories. */ 720 if (ENABLE_SECURE && IS_PATH_WITH_DIR (single_locale)) 721 /* Ingore this entry. */ 722 continue; 723 } 724 725 /* If the current locale value is C (or POSIX) we don't load a 726 domain. Return the MSGID. */ 727 if (strcmp (single_locale, "C") == 0 728 || strcmp (single_locale, "POSIX") == 0) 729 break; 730 731 /* Find structure describing the message catalog matching the 732 DOMAINNAME and CATEGORY. */ 733 domain = _nl_find_domain (dirname, single_locale, xdomainname, binding); 734 735 if (domain != NULL) 736 { 737 #if defined IN_LIBGLOCALE 738 retval = _nl_find_msg (domain, binding, encoding, msgid1, &retlen); 739 #else 740 retval = _nl_find_msg (domain, binding, msgid1, 1, &retlen); 741 #endif 742 743 if (retval == NULL) 744 { 745 int cnt; 746 747 for (cnt = 0; domain->successor[cnt] != NULL; ++cnt) 748 { 749 #if defined IN_LIBGLOCALE 750 retval = _nl_find_msg (domain->successor[cnt], binding, 751 encoding, msgid1, &retlen); 752 #else 753 retval = _nl_find_msg (domain->successor[cnt], binding, 754 msgid1, 1, &retlen); 755 #endif 756 757 if (retval != NULL) 758 { 759 domain = domain->successor[cnt]; 760 break; 761 } 762 } 763 } 764 765 /* Returning -1 means that some resource problem exists 766 (likely memory) and that the strings could not be 767 converted. Return the original strings. */ 768 if (__builtin_expect (retval == (char *) -1, 0)) 769 break; 770 771 if (retval != NULL) 772 { 773 /* Found the translation of MSGID1 in domain DOMAIN: 774 starting at RETVAL, RETLEN bytes. */ 775 FREE_BLOCKS (block_list); 776 #if defined HAVE_TSEARCH || defined _LIBC 777 if (foundp == NULL) 778 { 779 /* Create a new entry and add it to the search tree. */ 780 size_t size; 781 struct known_translation_t *newp; 782 783 size = offsetof (struct known_translation_t, msgid) 784 + msgid_len + domainname_len + 1; 785 # ifdef HAVE_PER_THREAD_LOCALE 786 size += strlen (localename) + 1; 787 # endif 788 newp = (struct known_translation_t *) malloc (size); 789 if (newp != NULL) 790 { 791 char *new_domainname; 792 # ifdef HAVE_PER_THREAD_LOCALE 793 char *new_localename; 794 # endif 795 796 new_domainname = mempcpy (newp->msgid, msgid1, msgid_len); 797 memcpy (new_domainname, domainname, domainname_len + 1); 798 # ifdef HAVE_PER_THREAD_LOCALE 799 new_localename = new_domainname + domainname_len + 1; 800 strcpy (new_localename, localename); 801 # endif 802 newp->domainname = new_domainname; 803 newp->category = category; 804 # ifdef HAVE_PER_THREAD_LOCALE 805 newp->localename = new_localename; 806 # endif 807 # ifdef IN_LIBGLOCALE 808 newp->encoding = encoding; 809 # endif 810 newp->counter = _nl_msg_cat_cntr; 811 newp->domain = domain; 812 newp->translation = retval; 813 newp->translation_length = retlen; 814 815 gl_rwlock_wrlock (tree_lock); 816 817 /* Insert the entry in the search tree. */ 818 foundp = (struct known_translation_t **) 819 tsearch (newp, &root, transcmp); 820 821 gl_rwlock_unlock (tree_lock); 822 823 if (foundp == NULL 824 || __builtin_expect (*foundp != newp, 0)) 825 /* The insert failed. */ 826 free (newp); 827 } 828 } 829 else 830 { 831 /* We can update the existing entry. */ 832 (*foundp)->counter = _nl_msg_cat_cntr; 833 (*foundp)->domain = domain; 834 (*foundp)->translation = retval; 835 (*foundp)->translation_length = retlen; 836 } 837 #endif 838 __set_errno (saved_errno); 839 840 /* Now deal with plural. */ 841 if (plural) 842 retval = plural_lookup (domain, n, retval, retlen); 843 844 gl_rwlock_unlock (_nl_state_lock); 845 return retval; 846 } 847 } 848 } 849 850 return_untranslated: 851 /* Return the untranslated MSGID. */ 852 FREE_BLOCKS (block_list); 853 gl_rwlock_unlock (_nl_state_lock); 854 #ifndef _LIBC 855 if (!ENABLE_SECURE) 856 { 857 extern void _nl_log_untranslated (const char *logfilename, 858 const char *domainname, 859 const char *msgid1, const char *msgid2, 860 int plural); 861 const char *logfilename = getenv ("GETTEXT_LOG_UNTRANSLATED"); 862 863 if (logfilename != NULL && logfilename[0] != '\0') 864 _nl_log_untranslated (logfilename, domainname, msgid1, msgid2, plural); 865 } 866 #endif 867 __set_errno (saved_errno); 868 return (plural == 0 869 ? (char *) msgid1 870 /* Use the Germanic plural rule. */ 871 : n == 1 ? (char *) msgid1 : (char *) msgid2); 872 } 873 874 875 /* Look up the translation of msgid within DOMAIN_FILE and DOMAINBINDING. 876 Return it if found. Return NULL if not found or in case of a conversion 877 failure (problem in the particular message catalog). Return (char *) -1 878 in case of a memory allocation failure during conversion (only if 879 ENCODING != NULL resp. CONVERT == true). */ 880 char * 881 internal_function 882 #ifdef IN_LIBGLOCALE 883 _nl_find_msg (struct loaded_l10nfile *domain_file, 884 struct binding *domainbinding, const char *encoding, 885 const char *msgid, 886 size_t *lengthp) 887 #else 888 _nl_find_msg (struct loaded_l10nfile *domain_file, 889 struct binding *domainbinding, 890 const char *msgid, int convert, 891 size_t *lengthp) 892 #endif 893 { 894 struct loaded_domain *domain; 895 nls_uint32 nstrings; 896 size_t act; 897 char *result; 898 size_t resultlen; 899 900 if (domain_file->decided <= 0) 901 _nl_load_domain (domain_file, domainbinding); 902 903 if (domain_file->data == NULL) 904 return NULL; 905 906 domain = (struct loaded_domain *) domain_file->data; 907 908 nstrings = domain->nstrings; 909 910 /* Locate the MSGID and its translation. */ 911 if (domain->hash_tab != NULL) 912 { 913 /* Use the hashing table. */ 914 nls_uint32 len = strlen (msgid); 915 nls_uint32 hash_val = __hash_string (msgid); 916 nls_uint32 idx = hash_val % domain->hash_size; 917 nls_uint32 incr = 1 + (hash_val % (domain->hash_size - 2)); 918 919 while (1) 920 { 921 nls_uint32 nstr = 922 W (domain->must_swap_hash_tab, domain->hash_tab[idx]); 923 924 if (nstr == 0) 925 /* Hash table entry is empty. */ 926 return NULL; 927 928 nstr--; 929 930 /* Compare msgid with the original string at index nstr. 931 We compare the lengths with >=, not ==, because plural entries 932 are represented by strings with an embedded NUL. */ 933 if (nstr < nstrings 934 ? W (domain->must_swap, domain->orig_tab[nstr].length) >= len 935 && (strcmp (msgid, 936 domain->data + W (domain->must_swap, 937 domain->orig_tab[nstr].offset)) 938 == 0) 939 : domain->orig_sysdep_tab[nstr - nstrings].length > len 940 && (strcmp (msgid, 941 domain->orig_sysdep_tab[nstr - nstrings].pointer) 942 == 0)) 943 { 944 act = nstr; 945 goto found; 946 } 947 948 if (idx >= domain->hash_size - incr) 949 idx -= domain->hash_size - incr; 950 else 951 idx += incr; 952 } 953 /* NOTREACHED */ 954 } 955 else 956 { 957 /* Try the default method: binary search in the sorted array of 958 messages. */ 959 size_t top, bottom; 960 961 bottom = 0; 962 top = nstrings; 963 while (bottom < top) 964 { 965 int cmp_val; 966 967 act = (bottom + top) / 2; 968 cmp_val = strcmp (msgid, (domain->data 969 + W (domain->must_swap, 970 domain->orig_tab[act].offset))); 971 if (cmp_val < 0) 972 top = act; 973 else if (cmp_val > 0) 974 bottom = act + 1; 975 else 976 goto found; 977 } 978 /* No translation was found. */ 979 return NULL; 980 } 981 982 found: 983 /* The translation was found at index ACT. If we have to convert the 984 string to use a different character set, this is the time. */ 985 if (act < nstrings) 986 { 987 result = (char *) 988 (domain->data + W (domain->must_swap, domain->trans_tab[act].offset)); 989 resultlen = W (domain->must_swap, domain->trans_tab[act].length) + 1; 990 } 991 else 992 { 993 result = (char *) domain->trans_sysdep_tab[act - nstrings].pointer; 994 resultlen = domain->trans_sysdep_tab[act - nstrings].length; 995 } 996 997 #if defined _LIBC || HAVE_ICONV 998 # ifdef IN_LIBGLOCALE 999 if (encoding != NULL) 1000 # else 1001 if (convert) 1002 # endif 1003 { 1004 /* We are supposed to do a conversion. */ 1005 # ifndef IN_LIBGLOCALE 1006 const char *encoding = get_output_charset (domainbinding); 1007 # endif 1008 1009 /* Search whether a table with converted translations for this 1010 encoding has already been allocated. */ 1011 size_t nconversions = domain->nconversions; 1012 struct converted_domain *convd = NULL; 1013 size_t i; 1014 1015 for (i = nconversions; i > 0; ) 1016 { 1017 i--; 1018 if (strcmp (domain->conversions[i].encoding, encoding) == 0) 1019 { 1020 convd = &domain->conversions[i]; 1021 break; 1022 } 1023 } 1024 1025 if (convd == NULL) 1026 { 1027 /* Allocate a table for the converted translations for this 1028 encoding. */ 1029 struct converted_domain *new_conversions = 1030 (struct converted_domain *) 1031 (domain->conversions != NULL 1032 ? realloc (domain->conversions, 1033 (nconversions + 1) * sizeof (struct converted_domain)) 1034 : malloc ((nconversions + 1) * sizeof (struct converted_domain))); 1035 1036 if (__builtin_expect (new_conversions == NULL, 0)) 1037 /* Nothing we can do, no more memory. We cannot use the 1038 translation because it might be encoded incorrectly. */ 1039 return (char *) -1; 1040 1041 domain->conversions = new_conversions; 1042 1043 /* Copy the 'encoding' string to permanent storage. */ 1044 encoding = strdup (encoding); 1045 if (__builtin_expect (encoding == NULL, 0)) 1046 /* Nothing we can do, no more memory. We cannot use the 1047 translation because it might be encoded incorrectly. */ 1048 return (char *) -1; 1049 1050 convd = &new_conversions[nconversions]; 1051 convd->encoding = encoding; 1052 1053 /* Find out about the character set the file is encoded with. 1054 This can be found (in textual form) in the entry "". If this 1055 entry does not exist or if this does not contain the 'charset=' 1056 information, we will assume the charset matches the one the 1057 current locale and we don't have to perform any conversion. */ 1058 # ifdef _LIBC 1059 convd->conv = (__gconv_t) -1; 1060 # else 1061 # if HAVE_ICONV 1062 convd->conv = (iconv_t) -1; 1063 # endif 1064 # endif 1065 { 1066 char *nullentry; 1067 size_t nullentrylen; 1068 1069 /* Get the header entry. This is a recursion, but it doesn't 1070 reallocate domain->conversions because we pass 1071 encoding = NULL or convert = 0, respectively. */ 1072 nullentry = 1073 # ifdef IN_LIBGLOCALE 1074 _nl_find_msg (domain_file, domainbinding, NULL, "", 1075 &nullentrylen); 1076 # else 1077 _nl_find_msg (domain_file, domainbinding, "", 0, &nullentrylen); 1078 # endif 1079 1080 if (nullentry != NULL) 1081 { 1082 const char *charsetstr; 1083 1084 charsetstr = strstr (nullentry, "charset="); 1085 if (charsetstr != NULL) 1086 { 1087 size_t len; 1088 char *charset; 1089 const char *outcharset; 1090 1091 charsetstr += strlen ("charset="); 1092 len = strcspn (charsetstr, " \t\n"); 1093 1094 charset = (char *) alloca (len + 1); 1095 # if defined _LIBC || HAVE_MEMPCPY 1096 *((char *) mempcpy (charset, charsetstr, len)) = '\0'; 1097 # else 1098 memcpy (charset, charsetstr, len); 1099 charset[len] = '\0'; 1100 # endif 1101 1102 outcharset = encoding; 1103 1104 # ifdef _LIBC 1105 /* We always want to use transliteration. */ 1106 outcharset = norm_add_slashes (outcharset, "TRANSLIT"); 1107 charset = norm_add_slashes (charset, ""); 1108 int r = __gconv_open (outcharset, charset, &convd->conv, 1109 GCONV_AVOID_NOCONV); 1110 if (__builtin_expect (r != __GCONV_OK, 0)) 1111 { 1112 /* If the output encoding is the same there is 1113 nothing to do. Otherwise do not use the 1114 translation at all. */ 1115 if (__builtin_expect (r != __GCONV_NOCONV, 1)) 1116 return NULL; 1117 1118 convd->conv = (__gconv_t) -1; 1119 } 1120 # else 1121 # if HAVE_ICONV 1122 /* When using GNU libc >= 2.2 or GNU libiconv >= 1.5, 1123 we want to use transliteration. */ 1124 # if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2) || __GLIBC__ > 2 \ 1125 || _LIBICONV_VERSION >= 0x0105 1126 if (strchr (outcharset, '/') == NULL) 1127 { 1128 char *tmp; 1129 1130 len = strlen (outcharset); 1131 tmp = (char *) alloca (len + 10 + 1); 1132 memcpy (tmp, outcharset, len); 1133 memcpy (tmp + len, "//TRANSLIT", 10 + 1); 1134 outcharset = tmp; 1135 1136 convd->conv = iconv_open (outcharset, charset); 1137 1138 freea (outcharset); 1139 } 1140 else 1141 # endif 1142 convd->conv = iconv_open (outcharset, charset); 1143 # endif 1144 # endif 1145 1146 freea (charset); 1147 } 1148 } 1149 } 1150 convd->conv_tab = NULL; 1151 /* Here domain->conversions is still == new_conversions. */ 1152 domain->nconversions++; 1153 } 1154 1155 if ( 1156 # ifdef _LIBC 1157 convd->conv != (__gconv_t) -1 1158 # else 1159 # if HAVE_ICONV 1160 convd->conv != (iconv_t) -1 1161 # endif 1162 # endif 1163 ) 1164 { 1165 /* We are supposed to do a conversion. First allocate an 1166 appropriate table with the same structure as the table 1167 of translations in the file, where we can put the pointers 1168 to the converted strings in. 1169 There is a slight complication with plural entries. They 1170 are represented by consecutive NUL terminated strings. We 1171 handle this case by converting RESULTLEN bytes, including 1172 NULs. */ 1173 1174 if (convd->conv_tab == NULL 1175 && ((convd->conv_tab = 1176 (char **) calloc (nstrings + domain->n_sysdep_strings, 1177 sizeof (char *))) 1178 == NULL)) 1179 /* Mark that we didn't succeed allocating a table. */ 1180 convd->conv_tab = (char **) -1; 1181 1182 if (__builtin_expect (convd->conv_tab == (char **) -1, 0)) 1183 /* Nothing we can do, no more memory. We cannot use the 1184 translation because it might be encoded incorrectly. */ 1185 return (char *) -1; 1186 1187 if (convd->conv_tab[act] == NULL) 1188 { 1189 /* We haven't used this string so far, so it is not 1190 translated yet. Do this now. */ 1191 /* We use a bit more efficient memory handling. 1192 We allocate always larger blocks which get used over 1193 time. This is faster than many small allocations. */ 1194 __libc_lock_define_initialized (static, lock) 1195 # define INITIAL_BLOCK_SIZE 4080 1196 static unsigned char *freemem; 1197 static size_t freemem_size; 1198 1199 const unsigned char *inbuf; 1200 unsigned char *outbuf; 1201 int malloc_count; 1202 # ifndef _LIBC 1203 transmem_block_t *transmem_list = NULL; 1204 # endif 1205 1206 __libc_lock_lock (lock); 1207 1208 inbuf = (const unsigned char *) result; 1209 outbuf = freemem + sizeof (size_t); 1210 1211 malloc_count = 0; 1212 while (1) 1213 { 1214 transmem_block_t *newmem; 1215 # ifdef _LIBC 1216 size_t non_reversible; 1217 int res; 1218 1219 if (freemem_size < sizeof (size_t)) 1220 goto resize_freemem; 1221 1222 res = __gconv (convd->conv, 1223 &inbuf, inbuf + resultlen, 1224 &outbuf, 1225 outbuf + freemem_size - sizeof (size_t), 1226 &non_reversible); 1227 1228 if (res == __GCONV_OK || res == __GCONV_EMPTY_INPUT) 1229 break; 1230 1231 if (res != __GCONV_FULL_OUTPUT) 1232 { 1233 /* We should not use the translation at all, it 1234 is incorrectly encoded. */ 1235 __libc_lock_unlock (lock); 1236 return NULL; 1237 } 1238 1239 inbuf = (const unsigned char *) result; 1240 # else 1241 # if HAVE_ICONV 1242 const char *inptr = (const char *) inbuf; 1243 size_t inleft = resultlen; 1244 char *outptr = (char *) outbuf; 1245 size_t outleft; 1246 1247 if (freemem_size < sizeof (size_t)) 1248 goto resize_freemem; 1249 1250 outleft = freemem_size - sizeof (size_t); 1251 if (iconv (convd->conv, 1252 (ICONV_CONST char **) &inptr, &inleft, 1253 &outptr, &outleft) 1254 != (size_t) (-1)) 1255 { 1256 outbuf = (unsigned char *) outptr; 1257 break; 1258 } 1259 if (errno != E2BIG) 1260 { 1261 __libc_lock_unlock (lock); 1262 return NULL; 1263 } 1264 # endif 1265 # endif 1266 1267 resize_freemem: 1268 /* We must allocate a new buffer or resize the old one. */ 1269 if (malloc_count > 0) 1270 { 1271 ++malloc_count; 1272 freemem_size = malloc_count * INITIAL_BLOCK_SIZE; 1273 newmem = (transmem_block_t *) realloc (transmem_list, 1274 freemem_size); 1275 # ifdef _LIBC 1276 if (newmem != NULL) 1277 transmem_list = transmem_list->next; 1278 else 1279 { 1280 struct transmem_list *old = transmem_list; 1281 1282 transmem_list = transmem_list->next; 1283 free (old); 1284 } 1285 # endif 1286 } 1287 else 1288 { 1289 malloc_count = 1; 1290 freemem_size = INITIAL_BLOCK_SIZE; 1291 newmem = (transmem_block_t *) malloc (freemem_size); 1292 } 1293 if (__builtin_expect (newmem == NULL, 0)) 1294 { 1295 freemem = NULL; 1296 freemem_size = 0; 1297 __libc_lock_unlock (lock); 1298 return (char *) -1; 1299 } 1300 1301 # ifdef _LIBC 1302 /* Add the block to the list of blocks we have to free 1303 at some point. */ 1304 newmem->next = transmem_list; 1305 transmem_list = newmem; 1306 1307 freemem = (unsigned char *) newmem->data; 1308 freemem_size -= offsetof (struct transmem_list, data); 1309 # else 1310 transmem_list = newmem; 1311 freemem = newmem; 1312 # endif 1313 1314 outbuf = freemem + sizeof (size_t); 1315 } 1316 1317 /* We have now in our buffer a converted string. Put this 1318 into the table of conversions. */ 1319 *(size_t *) freemem = outbuf - freemem - sizeof (size_t); 1320 convd->conv_tab[act] = (char *) freemem; 1321 /* Shrink freemem, but keep it aligned. */ 1322 freemem_size -= outbuf - freemem; 1323 freemem = outbuf; 1324 freemem += freemem_size & (alignof (size_t) - 1); 1325 freemem_size = freemem_size & ~ (alignof (size_t) - 1); 1326 1327 __libc_lock_unlock (lock); 1328 } 1329 1330 /* Now convd->conv_tab[act] contains the translation of all 1331 the plural variants. */ 1332 result = convd->conv_tab[act] + sizeof (size_t); 1333 resultlen = *(size_t *) convd->conv_tab[act]; 1334 } 1335 } 1336 1337 /* The result string is converted. */ 1338 1339 #endif /* _LIBC || HAVE_ICONV */ 1340 1341 *lengthp = resultlen; 1342 return result; 1343 } 1344 1345 1346 /* Look up a plural variant. */ 1347 static char * 1348 internal_function 1349 plural_lookup (struct loaded_l10nfile *domain, unsigned long int n, 1350 const char *translation, size_t translation_len) 1351 { 1352 struct loaded_domain *domaindata = (struct loaded_domain *) domain->data; 1353 unsigned long int index; 1354 const char *p; 1355 1356 index = plural_eval (domaindata->plural, n); 1357 if (index >= domaindata->nplurals) 1358 /* This should never happen. It means the plural expression and the 1359 given maximum value do not match. */ 1360 index = 0; 1361 1362 /* Skip INDEX strings at TRANSLATION. */ 1363 p = translation; 1364 while (index-- > 0) 1365 { 1366 #ifdef _LIBC 1367 p = __rawmemchr (p, '\0'); 1368 #else 1369 p = strchr (p, '\0'); 1370 #endif 1371 /* And skip over the NUL byte. */ 1372 p++; 1373 1374 if (p >= translation + translation_len) 1375 /* This should never happen. It means the plural expression 1376 evaluated to a value larger than the number of variants 1377 available for MSGID1. */ 1378 return (char *) translation; 1379 } 1380 return (char *) p; 1381 } 1382 1383 #ifndef _LIBC 1384 /* Return string representation of locale CATEGORY. */ 1385 static const char * 1386 internal_function 1387 category_to_name (int category) 1388 { 1389 const char *retval; 1390 1391 switch (category) 1392 { 1393 #ifdef LC_COLLATE 1394 case LC_COLLATE: 1395 retval = "LC_COLLATE"; 1396 break; 1397 #endif 1398 #ifdef LC_CTYPE 1399 case LC_CTYPE: 1400 retval = "LC_CTYPE"; 1401 break; 1402 #endif 1403 #ifdef LC_MONETARY 1404 case LC_MONETARY: 1405 retval = "LC_MONETARY"; 1406 break; 1407 #endif 1408 #ifdef LC_NUMERIC 1409 case LC_NUMERIC: 1410 retval = "LC_NUMERIC"; 1411 break; 1412 #endif 1413 #ifdef LC_TIME 1414 case LC_TIME: 1415 retval = "LC_TIME"; 1416 break; 1417 #endif 1418 #ifdef LC_MESSAGES 1419 case LC_MESSAGES: 1420 retval = "LC_MESSAGES"; 1421 break; 1422 #endif 1423 #ifdef LC_RESPONSE 1424 case LC_RESPONSE: 1425 retval = "LC_RESPONSE"; 1426 break; 1427 #endif 1428 #ifdef LC_ALL 1429 case LC_ALL: 1430 /* This might not make sense but is perhaps better than any other 1431 value. */ 1432 retval = "LC_ALL"; 1433 break; 1434 #endif 1435 default: 1436 /* If you have a better idea for a default value let me know. */ 1437 retval = "LC_XXX"; 1438 } 1439 1440 return retval; 1441 } 1442 #endif 1443 1444 /* Guess value of current locale from value of the environment variables 1445 or system-dependent defaults. */ 1446 static const char * 1447 internal_function 1448 #ifdef IN_LIBGLOCALE 1449 guess_category_value (int category, const char *categoryname, 1450 const char *locale) 1451 1452 #else 1453 guess_category_value (int category, const char *categoryname) 1454 #endif 1455 { 1456 const char *language; 1457 #ifndef IN_LIBGLOCALE 1458 const char *locale; 1459 # ifndef _LIBC 1460 const char *language_default; 1461 int locale_defaulted; 1462 # endif 1463 #endif 1464 1465 /* We use the settings in the following order: 1466 1. The value of the environment variable 'LANGUAGE'. This is a GNU 1467 extension. Its value can be a colon-separated list of locale names. 1468 2. The value of the environment variable 'LC_ALL', 'LC_xxx', or 'LANG'. 1469 More precisely, the first among these that is set to a non-empty value. 1470 This is how POSIX specifies it. The value is a single locale name. 1471 3. A system-dependent preference list of languages. Its value can be a 1472 colon-separated list of locale names. 1473 4. A system-dependent default locale name. 1474 This way: 1475 - System-dependent settings can be overridden by environment variables. 1476 - If the system provides both a list of languages and a default locale, 1477 the former is used. */ 1478 1479 #ifndef IN_LIBGLOCALE 1480 /* Fetch the locale name, through the POSIX method of looking to `LC_ALL', 1481 `LC_xxx', and `LANG'. On some systems this can be done by the 1482 `setlocale' function itself. */ 1483 # ifdef _LIBC 1484 locale = __current_locale_name (category); 1485 # else 1486 # if HAVE_STRUCT___LOCALE_STRUCT___NAMES && defined USE_IN_GETTEXT_TESTS 1487 /* The __names field is not public glibc API and must therefore not be used 1488 in code that is installed in public locations. */ 1489 locale_t thread_locale = uselocale (NULL); 1490 if (thread_locale != LC_GLOBAL_LOCALE) 1491 { 1492 locale = thread_locale->__names[category]; 1493 locale_defaulted = 0; 1494 } 1495 else 1496 # endif 1497 { 1498 locale = _nl_locale_name_posix (category, categoryname); 1499 locale_defaulted = 0; 1500 if (locale == NULL) 1501 { 1502 locale = _nl_locale_name_default (); 1503 locale_defaulted = 1; 1504 } 1505 } 1506 # endif 1507 #endif 1508 1509 /* Ignore LANGUAGE and its system-dependent analogon if the locale is set 1510 to "C" because 1511 1. "C" locale usually uses the ASCII encoding, and most international 1512 messages use non-ASCII characters. These characters get displayed 1513 as question marks (if using glibc's iconv()) or as invalid 8-bit 1514 characters (because other iconv()s refuse to convert most non-ASCII 1515 characters to ASCII). In any case, the output is ugly. 1516 2. The precise output of some programs in the "C" locale is specified 1517 by POSIX and should not depend on environment variables like 1518 "LANGUAGE" or system-dependent information. We allow such programs 1519 to use gettext(). */ 1520 if (strcmp (locale, "C") == 0) 1521 return locale; 1522 1523 /* The highest priority value is the value of the 'LANGUAGE' environment 1524 variable. */ 1525 language = getenv ("LANGUAGE"); 1526 if (language != NULL && language[0] != '\0') 1527 return language; 1528 #if !defined IN_LIBGLOCALE && !defined _LIBC 1529 /* The next priority value is the locale name, if not defaulted. */ 1530 if (locale_defaulted) 1531 { 1532 /* The next priority value is the default language preferences list. */ 1533 language_default = _nl_language_preferences_default (); 1534 if (language_default != NULL) 1535 return language_default; 1536 } 1537 /* The least priority value is the locale name, if defaulted. */ 1538 #endif 1539 return locale; 1540 } 1541 1542 #if (defined _LIBC || HAVE_ICONV) && !defined IN_LIBGLOCALE 1543 /* Returns the output charset. */ 1544 static const char * 1545 internal_function 1546 get_output_charset (struct binding *domainbinding) 1547 { 1548 /* The output charset should normally be determined by the locale. But 1549 sometimes the locale is not used or not correctly set up, so we provide 1550 a possibility for the user to override this: the OUTPUT_CHARSET 1551 environment variable. Moreover, the value specified through 1552 bind_textdomain_codeset overrides both. */ 1553 if (domainbinding != NULL && domainbinding->codeset != NULL) 1554 return domainbinding->codeset; 1555 else 1556 { 1557 /* For speed reasons, we look at the value of OUTPUT_CHARSET only 1558 once. This is a user variable that is not supposed to change 1559 during a program run. */ 1560 static char *output_charset_cache; 1561 static int output_charset_cached; 1562 1563 if (!output_charset_cached) 1564 { 1565 const char *value = getenv ("OUTPUT_CHARSET"); 1566 1567 if (value != NULL && value[0] != '\0') 1568 { 1569 size_t len = strlen (value) + 1; 1570 char *value_copy = (char *) malloc (len); 1571 1572 if (value_copy != NULL) 1573 memcpy (value_copy, value, len); 1574 output_charset_cache = value_copy; 1575 } 1576 output_charset_cached = 1; 1577 } 1578 1579 if (output_charset_cache != NULL) 1580 return output_charset_cache; 1581 else 1582 { 1583 # ifdef _LIBC 1584 return _NL_CURRENT (LC_CTYPE, CODESET); 1585 # else 1586 # if HAVE_ICONV 1587 extern const char *locale_charset (void); 1588 return locale_charset (); 1589 # endif 1590 # endif 1591 } 1592 } 1593 } 1594 #endif 1595 1596 /* @@ begin of epilog @@ */ 1597 1598 /* We don't want libintl.a to depend on any other library. So we 1599 avoid the non-standard function stpcpy. In GNU C Library this 1600 function is available, though. Also allow the symbol HAVE_STPCPY 1601 to be defined. */ 1602 #if !_LIBC && !HAVE_STPCPY 1603 static char * 1604 stpcpy (char *dest, const char *src) 1605 { 1606 while ((*dest++ = *src++) != '\0') 1607 /* Do nothing. */ ; 1608 return dest - 1; 1609 } 1610 #endif 1611 1612 #if !_LIBC && !HAVE_MEMPCPY 1613 static void * 1614 mempcpy (void *dest, const void *src, size_t n) 1615 { 1616 return (void *) ((char *) memcpy (dest, src, n) + n); 1617 } 1618 #endif 1619 1620 1621 #ifdef _LIBC 1622 /* If we want to free all resources we have to do some work at 1623 program's end. */ 1624 libc_freeres_fn (free_mem) 1625 { 1626 void *old; 1627 1628 while (_nl_domain_bindings != NULL) 1629 { 1630 struct binding *oldp = _nl_domain_bindings; 1631 _nl_domain_bindings = _nl_domain_bindings->next; 1632 if (oldp->dirname != _nl_default_dirname) 1633 /* Yes, this is a pointer comparison. */ 1634 free (oldp->dirname); 1635 free (oldp->codeset); 1636 free (oldp); 1637 } 1638 1639 if (_nl_current_default_domain != _nl_default_default_domain) 1640 /* Yes, again a pointer comparison. */ 1641 free ((char *) _nl_current_default_domain); 1642 1643 /* Remove the search tree with the known translations. */ 1644 __tdestroy (root, free); 1645 root = NULL; 1646 1647 while (transmem_list != NULL) 1648 { 1649 old = transmem_list; 1650 transmem_list = transmem_list->next; 1651 free (old); 1652 } 1653 } 1654 #endif 1655
Indexes created Fri Apr 10 00:22:58 UTC 2026