1 /* Implementation of the internal dcigettext function. 2 Copyright (C) 1995-1999, 2000-2003 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 #include <sys/types.h> 31 32 #ifdef __GNUC__ 33 # define alloca __builtin_alloca 34 # define HAVE_ALLOCA 1 35 #else 36 # ifdef _MSC_VER 37 # include <malloc.h> 38 # define alloca _alloca 39 # else 40 # if defined HAVE_ALLOCA_H || defined _LIBC 41 # include <alloca.h> 42 # else 43 # ifdef _AIX 44 #pragma alloca 45 # else 46 # ifndef alloca 47 char *alloca (); 48 # endif 49 # endif 50 # endif 51 # endif 52 #endif 53 54 #include <errno.h> 55 #ifndef errno 56 extern int errno; 57 #endif 58 #ifndef __set_errno 59 # define __set_errno(val) errno = (val) 60 #endif 61 62 #include <stddef.h> 63 #include <stdlib.h> 64 #include <string.h> 65 66 #if defined HAVE_UNISTD_H || defined _LIBC 67 # include <unistd.h> 68 #endif 69 70 #include <locale.h> 71 72 #ifdef _LIBC 73 /* Guess whether integer division by zero raises signal SIGFPE. 74 Set to 1 only if you know for sure. In case of doubt, set to 0. */ 75 # if defined __alpha__ || defined __arm__ || defined __i386__ \ 76 || defined __m68k__ || defined __s390__ 77 # define INTDIV0_RAISES_SIGFPE 1 78 # else 79 # define INTDIV0_RAISES_SIGFPE 0 80 # endif 81 #endif 82 #if !INTDIV0_RAISES_SIGFPE 83 # include <signal.h> 84 #endif 85 86 #if defined HAVE_SYS_PARAM_H || defined _LIBC 87 # include <sys/param.h> 88 #endif 89 90 #include "gettextP.h" 91 #include "plural-exp.h" 92 #ifdef _LIBC 93 # include <libintl.h> 94 #else 95 # include "libgnuintl.h" 96 #endif 97 #include "hash-string.h" 98 99 /* Thread safetyness. */ 100 #ifdef _LIBC 101 # include <bits/libc-lock.h> 102 #else 103 /* Provide dummy implementation if this is outside glibc. */ 104 # define __libc_lock_define_initialized(CLASS, NAME) 105 # define __libc_lock_lock(NAME) 106 # define __libc_lock_unlock(NAME) 107 # define __libc_rwlock_define_initialized(CLASS, NAME) 108 # define __libc_rwlock_rdlock(NAME) 109 # define __libc_rwlock_unlock(NAME) 110 #endif 111 112 /* Alignment of types. */ 113 #if defined __GNUC__ && __GNUC__ >= 2 114 # define alignof(TYPE) __alignof__ (TYPE) 115 #else 116 # define alignof(TYPE) \ 117 ((int) &((struct { char dummy1; TYPE dummy2; } *) 0)->dummy2) 118 #endif 119 120 /* The internal variables in the standalone libintl.a must have different 121 names than the internal variables in GNU libc, otherwise programs 122 using libintl.a cannot be linked statically. */ 123 #if !defined _LIBC 124 # define _nl_default_default_domain libintl_nl_default_default_domain 125 # define _nl_current_default_domain libintl_nl_current_default_domain 126 # define _nl_default_dirname libintl_nl_default_dirname 127 # define _nl_domain_bindings libintl_nl_domain_bindings 128 #endif 129 130 /* Some compilers, like SunOS4 cc, don't have offsetof in <stddef.h>. */ 131 #ifndef offsetof 132 # define offsetof(type,ident) ((size_t)&(((type*)0)->ident)) 133 #endif 134 135 /* @@ end of prolog @@ */ 136 137 #ifdef _LIBC 138 /* Rename the non ANSI C functions. This is required by the standard 139 because some ANSI C functions will require linking with this object 140 file and the name space must not be polluted. */ 141 # define getcwd __getcwd 142 # ifndef stpcpy 143 # define stpcpy __stpcpy 144 # endif 145 # define tfind __tfind 146 #else 147 # if !defined HAVE_GETCWD 148 char *getwd (); 149 # define getcwd(buf, max) getwd (buf) 150 # else 151 # if VMS 152 # define getcwd(buf, max) (getcwd) (buf, max, 0) 153 # else 154 char *getcwd (); 155 # endif 156 # endif 157 # ifndef HAVE_STPCPY 158 static char *stpcpy (char *dest, const char *src); 159 # endif 160 # ifndef HAVE_MEMPCPY 161 static void *mempcpy (void *dest, const void *src, size_t n); 162 # endif 163 #endif 164 165 /* Amount to increase buffer size by in each try. */ 166 #define PATH_INCR 32 167 168 /* The following is from pathmax.h. */ 169 /* Non-POSIX BSD systems might have gcc's limits.h, which doesn't define 170 PATH_MAX but might cause redefinition warnings when sys/param.h is 171 later included (as on MORE/BSD 4.3). */ 172 #if defined _POSIX_VERSION || (defined HAVE_LIMITS_H && !defined __GNUC__) 173 # include <limits.h> 174 #endif 175 176 #ifndef _POSIX_PATH_MAX 177 # define _POSIX_PATH_MAX 255 178 #endif 179 180 #if !defined PATH_MAX && defined _PC_PATH_MAX 181 # define PATH_MAX (pathconf ("/", _PC_PATH_MAX) < 1 ? 1024 : pathconf ("/", _PC_PATH_MAX)) 182 #endif 183 184 /* Don't include sys/param.h if it already has been. */ 185 #if defined HAVE_SYS_PARAM_H && !defined PATH_MAX && !defined MAXPATHLEN 186 # include <sys/param.h> 187 #endif 188 189 #if !defined PATH_MAX && defined MAXPATHLEN 190 # define PATH_MAX MAXPATHLEN 191 #endif 192 193 #ifndef PATH_MAX 194 # define PATH_MAX _POSIX_PATH_MAX 195 #endif 196 197 /* Pathname support. 198 ISSLASH(C) tests whether C is a directory separator character. 199 IS_ABSOLUTE_PATH(P) tests whether P is an absolute path. If it is not, 200 it may be concatenated to a directory pathname. 201 IS_PATH_WITH_DIR(P) tests whether P contains a directory specification. 202 */ 203 #if defined _WIN32 || defined __WIN32__ || defined __EMX__ || defined __DJGPP__ 204 /* Win32, OS/2, DOS */ 205 # define ISSLASH(C) ((C) == '/' || (C) == '\\') 206 # define HAS_DEVICE(P) \ 207 ((((P)[0] >= 'A' && (P)[0] <= 'Z') || ((P)[0] >= 'a' && (P)[0] <= 'z')) \ 208 && (P)[1] == ':') 209 # define IS_ABSOLUTE_PATH(P) (ISSLASH ((P)[0]) || HAS_DEVICE (P)) 210 # define IS_PATH_WITH_DIR(P) \ 211 (strchr (P, '/') != NULL || strchr (P, '\\') != NULL || HAS_DEVICE (P)) 212 #else 213 /* Unix */ 214 # define ISSLASH(C) ((C) == '/') 215 # define IS_ABSOLUTE_PATH(P) ISSLASH ((P)[0]) 216 # define IS_PATH_WITH_DIR(P) (strchr (P, '/') != NULL) 217 #endif 218 219 /* This is the type used for the search tree where known translations 220 are stored. */ 221 struct known_translation_t 222 { 223 /* Domain in which to search. */ 224 char *domainname; 225 226 /* The category. */ 227 int category; 228 229 /* State of the catalog counter at the point the string was found. */ 230 int counter; 231 232 /* Catalog where the string was found. */ 233 struct loaded_l10nfile *domain; 234 235 /* And finally the translation. */ 236 const char *translation; 237 size_t translation_length; 238 239 /* Pointer to the string in question. */ 240 char msgid[ZERO]; 241 }; 242 243 /* Root of the search tree with known translations. We can use this 244 only if the system provides the `tsearch' function family. */ 245 #if defined HAVE_TSEARCH || defined _LIBC 246 # include <search.h> 247 248 static void *root; 249 250 # ifdef _LIBC 251 # define tsearch __tsearch 252 # endif 253 254 /* Function to compare two entries in the table of known translations. */ 255 static int 256 transcmp (const void *p1, const void *p2) 257 { 258 const struct known_translation_t *s1; 259 const struct known_translation_t *s2; 260 int result; 261 262 s1 = (const struct known_translation_t *) p1; 263 s2 = (const struct known_translation_t *) p2; 264 265 result = strcmp (s1->msgid, s2->msgid); 266 if (result == 0) 267 { 268 result = strcmp (s1->domainname, s2->domainname); 269 if (result == 0) 270 /* We compare the category last (though this is the cheapest 271 operation) since it is hopefully always the same (namely 272 LC_MESSAGES). */ 273 result = s1->category - s2->category; 274 } 275 276 return result; 277 } 278 #endif 279 280 #ifndef INTVARDEF 281 # define INTVARDEF(name) 282 #endif 283 #ifndef INTUSE 284 # define INTUSE(name) name 285 #endif 286 287 /* Name of the default domain used for gettext(3) prior any call to 288 textdomain(3). The default value for this is "messages". */ 289 const char _nl_default_default_domain[] attribute_hidden = "messages"; 290 291 /* Value used as the default domain for gettext(3). */ 292 const char *_nl_current_default_domain attribute_hidden 293 = _nl_default_default_domain; 294 295 /* Contains the default location of the message catalogs. */ 296 #if defined __EMX__ 297 extern const char _nl_default_dirname[]; 298 #else 299 const char _nl_default_dirname[] = LOCALEDIR; 300 INTVARDEF (_nl_default_dirname) 301 #endif 302 303 /* List with bindings of specific domains created by bindtextdomain() 304 calls. */ 305 struct binding *_nl_domain_bindings; 306 307 /* Prototypes for local functions. */ 308 static char *plural_lookup (struct loaded_l10nfile *domain, 309 unsigned long int n, 310 const char *translation, size_t translation_len) 311 internal_function; 312 static const char *guess_category_value (int category, 313 const char *categoryname) 314 internal_function; 315 #ifdef _LIBC 316 # include "../locale/localeinfo.h" 317 # define category_to_name(category) _nl_category_names[category] 318 #else 319 static const char *category_to_name (int category) internal_function; 320 #endif 321 322 323 /* For those loosing systems which don't have `alloca' we have to add 324 some additional code emulating it. */ 325 #ifdef HAVE_ALLOCA 326 /* Nothing has to be done. */ 327 # define freea(p) /* nothing */ 328 # define ADD_BLOCK(list, address) /* nothing */ 329 # define FREE_BLOCKS(list) /* nothing */ 330 #else 331 struct block_list 332 { 333 void *address; 334 struct block_list *next; 335 }; 336 # define ADD_BLOCK(list, addr) \ 337 do { \ 338 struct block_list *newp = (struct block_list *) malloc (sizeof (*newp)); \ 339 /* If we cannot get a free block we cannot add the new element to \ 340 the list. */ \ 341 if (newp != NULL) { \ 342 newp->address = (addr); \ 343 newp->next = (list); \ 344 (list) = newp; \ 345 } \ 346 } while (0) 347 # define FREE_BLOCKS(list) \ 348 do { \ 349 while (list != NULL) { \ 350 struct block_list *old = list; \ 351 list = list->next; \ 352 free (old->address); \ 353 free (old); \ 354 } \ 355 } while (0) 356 # undef alloca 357 # define alloca(size) (malloc (size)) 358 # define freea(p) free (p) 359 #endif /* have alloca */ 360 361 362 #ifdef _LIBC 363 /* List of blocks allocated for translations. */ 364 typedef struct transmem_list 365 { 366 struct transmem_list *next; 367 char data[ZERO]; 368 } transmem_block_t; 369 static struct transmem_list *transmem_list; 370 #else 371 typedef unsigned char transmem_block_t; 372 #endif 373 374 375 /* Names for the libintl functions are a problem. They must not clash 376 with existing names and they should follow ANSI C. But this source 377 code is also used in GNU C Library where the names have a __ 378 prefix. So we have to make a difference here. */ 379 #ifdef _LIBC 380 # define DCIGETTEXT __dcigettext 381 #else 382 # define DCIGETTEXT libintl_dcigettext 383 #endif 384 385 /* Lock variable to protect the global data in the gettext implementation. */ 386 #ifdef _LIBC 387 __libc_rwlock_define_initialized (, _nl_state_lock attribute_hidden) 388 #endif 389 390 /* Checking whether the binaries runs SUID must be done and glibc provides 391 easier methods therefore we make a difference here. */ 392 #ifdef _LIBC 393 # define ENABLE_SECURE __libc_enable_secure 394 # define DETERMINE_SECURE 395 #else 396 # ifndef HAVE_GETUID 397 # define getuid() 0 398 # endif 399 # ifndef HAVE_GETGID 400 # define getgid() 0 401 # endif 402 # ifndef HAVE_GETEUID 403 # define geteuid() getuid() 404 # endif 405 # ifndef HAVE_GETEGID 406 # define getegid() getgid() 407 # endif 408 static int enable_secure; 409 # define ENABLE_SECURE (enable_secure == 1) 410 # define DETERMINE_SECURE \ 411 if (enable_secure == 0) \ 412 { \ 413 if (getuid () != geteuid () || getgid () != getegid ()) \ 414 enable_secure = 1; \ 415 else \ 416 enable_secure = -1; \ 417 } 418 #endif 419 420 /* Get the function to evaluate the plural expression. */ 421 #include "eval-plural.h" 422 423 /* Look up MSGID in the DOMAINNAME message catalog for the current 424 CATEGORY locale and, if PLURAL is nonzero, search over string 425 depending on the plural form determined by N. */ 426 char * 427 DCIGETTEXT (const char *domainname, const char *msgid1, const char *msgid2, 428 int plural, unsigned long int n, int category) 429 { 430 #ifndef HAVE_ALLOCA 431 struct block_list *block_list = NULL; 432 #endif 433 struct loaded_l10nfile *domain; 434 struct binding *binding; 435 const char *categoryname; 436 const char *categoryvalue; 437 char *dirname, *xdomainname; 438 char *single_locale; 439 char *retval; 440 size_t retlen; 441 int saved_errno; 442 #if defined HAVE_TSEARCH || defined _LIBC 443 struct known_translation_t *search; 444 struct known_translation_t **foundp = NULL; 445 size_t msgid_len; 446 #endif 447 size_t domainname_len; 448 449 /* If no real MSGID is given return NULL. */ 450 if (msgid1 == NULL) 451 return NULL; 452 453 #ifdef _LIBC 454 if (category < 0 || category >= __LC_LAST || category == LC_ALL) 455 /* Bogus. */ 456 return (plural == 0 457 ? (char *) msgid1 458 /* Use the Germanic plural rule. */ 459 : n == 1 ? (char *) msgid1 : (char *) msgid2); 460 #endif 461 462 __libc_rwlock_rdlock (_nl_state_lock); 463 464 /* If DOMAINNAME is NULL, we are interested in the default domain. If 465 CATEGORY is not LC_MESSAGES this might not make much sense but the 466 definition left this undefined. */ 467 if (domainname == NULL) 468 domainname = _nl_current_default_domain; 469 470 /* OS/2 specific: backward compatibility with older libintl versions */ 471 #ifdef LC_MESSAGES_COMPAT 472 if (category == LC_MESSAGES_COMPAT) 473 category = LC_MESSAGES; 474 #endif 475 476 #if defined HAVE_TSEARCH || defined _LIBC 477 msgid_len = strlen (msgid1) + 1; 478 479 /* Try to find the translation among those which we found at 480 some time. */ 481 search = (struct known_translation_t *) 482 alloca (offsetof (struct known_translation_t, msgid) + msgid_len); 483 memcpy (search->msgid, msgid1, msgid_len); 484 search->domainname = (char *) domainname; 485 search->category = category; 486 487 foundp = (struct known_translation_t **) tfind (search, &root, transcmp); 488 freea (search); 489 if (foundp != NULL && (*foundp)->counter == _nl_msg_cat_cntr) 490 { 491 /* Now deal with plural. */ 492 if (plural) 493 retval = plural_lookup ((*foundp)->domain, n, (*foundp)->translation, 494 (*foundp)->translation_length); 495 else 496 retval = (char *) (*foundp)->translation; 497 498 __libc_rwlock_unlock (_nl_state_lock); 499 return retval; 500 } 501 #endif 502 503 /* Preserve the `errno' value. */ 504 saved_errno = errno; 505 506 /* See whether this is a SUID binary or not. */ 507 DETERMINE_SECURE; 508 509 /* First find matching binding. */ 510 for (binding = _nl_domain_bindings; binding != NULL; binding = binding->next) 511 { 512 int compare = strcmp (domainname, binding->domainname); 513 if (compare == 0) 514 /* We found it! */ 515 break; 516 if (compare < 0) 517 { 518 /* It is not in the list. */ 519 binding = NULL; 520 break; 521 } 522 } 523 524 if (binding == NULL) 525 dirname = (char *) INTUSE(_nl_default_dirname); 526 else if (IS_ABSOLUTE_PATH (binding->dirname)) 527 dirname = binding->dirname; 528 else 529 { 530 /* We have a relative path. Make it absolute now. */ 531 size_t dirname_len = strlen (binding->dirname) + 1; 532 size_t path_max; 533 char *ret; 534 535 path_max = (unsigned int) PATH_MAX; 536 path_max += 2; /* The getcwd docs say to do this. */ 537 538 for (;;) 539 { 540 dirname = (char *) alloca (path_max + dirname_len); 541 ADD_BLOCK (block_list, dirname); 542 543 __set_errno (0); 544 ret = getcwd (dirname, path_max); 545 if (ret != NULL || errno != ERANGE) 546 break; 547 548 path_max += path_max / 2; 549 path_max += PATH_INCR; 550 } 551 552 if (ret == NULL) 553 /* We cannot get the current working directory. Don't signal an 554 error but simply return the default string. */ 555 goto return_untranslated; 556 557 stpcpy (stpcpy (strchr (dirname, '\0'), "/"), binding->dirname); 558 } 559 560 /* Now determine the symbolic name of CATEGORY and its value. */ 561 categoryname = category_to_name (category); 562 categoryvalue = guess_category_value (category, categoryname); 563 564 domainname_len = strlen (domainname); 565 xdomainname = (char *) alloca (strlen (categoryname) 566 + domainname_len + 5); 567 ADD_BLOCK (block_list, xdomainname); 568 569 stpcpy (mempcpy (stpcpy (stpcpy (xdomainname, categoryname), "/"), 570 domainname, domainname_len), 571 ".mo"); 572 573 /* Creating working area. */ 574 single_locale = (char *) alloca (strlen (categoryvalue) + 1); 575 ADD_BLOCK (block_list, single_locale); 576 577 578 /* Search for the given string. This is a loop because we perhaps 579 got an ordered list of languages to consider for the translation. */ 580 while (1) 581 { 582 /* Make CATEGORYVALUE point to the next element of the list. */ 583 while (categoryvalue[0] != '\0' && categoryvalue[0] == ':') 584 ++categoryvalue; 585 if (categoryvalue[0] == '\0') 586 { 587 /* The whole contents of CATEGORYVALUE has been searched but 588 no valid entry has been found. We solve this situation 589 by implicitly appending a "C" entry, i.e. no translation 590 will take place. */ 591 single_locale[0] = 'C'; 592 single_locale[1] = '\0'; 593 } 594 else 595 { 596 char *cp = single_locale; 597 while (categoryvalue[0] != '\0' && categoryvalue[0] != ':') 598 *cp++ = *categoryvalue++; 599 *cp = '\0'; 600 601 /* When this is a SUID binary we must not allow accessing files 602 outside the dedicated directories. */ 603 if (ENABLE_SECURE && IS_PATH_WITH_DIR (single_locale)) 604 /* Ingore this entry. */ 605 continue; 606 } 607 608 /* If the current locale value is C (or POSIX) we don't load a 609 domain. Return the MSGID. */ 610 if (strcmp (single_locale, "C") == 0 611 || strcmp (single_locale, "POSIX") == 0) 612 break; 613 614 /* Find structure describing the message catalog matching the 615 DOMAINNAME and CATEGORY. */ 616 domain = _nl_find_domain (dirname, single_locale, xdomainname, binding); 617 618 if (domain != NULL) 619 { 620 retval = _nl_find_msg (domain, binding, msgid1, &retlen); 621 622 if (retval == NULL) 623 { 624 int cnt; 625 626 for (cnt = 0; domain->successor[cnt] != NULL; ++cnt) 627 { 628 retval = _nl_find_msg (domain->successor[cnt], binding, 629 msgid1, &retlen); 630 631 if (retval != NULL) 632 { 633 domain = domain->successor[cnt]; 634 break; 635 } 636 } 637 } 638 639 if (retval != NULL) 640 { 641 /* Found the translation of MSGID1 in domain DOMAIN: 642 starting at RETVAL, RETLEN bytes. */ 643 FREE_BLOCKS (block_list); 644 #if defined HAVE_TSEARCH || defined _LIBC 645 if (foundp == NULL) 646 { 647 /* Create a new entry and add it to the search tree. */ 648 struct known_translation_t *newp; 649 650 newp = (struct known_translation_t *) 651 malloc (offsetof (struct known_translation_t, msgid) 652 + msgid_len + domainname_len + 1); 653 if (newp != NULL) 654 { 655 newp->domainname = 656 mempcpy (newp->msgid, msgid1, msgid_len); 657 memcpy (newp->domainname, domainname, domainname_len + 1); 658 newp->category = category; 659 newp->counter = _nl_msg_cat_cntr; 660 newp->domain = domain; 661 newp->translation = retval; 662 newp->translation_length = retlen; 663 664 /* Insert the entry in the search tree. */ 665 foundp = (struct known_translation_t **) 666 tsearch (newp, &root, transcmp); 667 if (foundp == NULL 668 || __builtin_expect (*foundp != newp, 0)) 669 /* The insert failed. */ 670 free (newp); 671 } 672 } 673 else 674 { 675 /* We can update the existing entry. */ 676 (*foundp)->counter = _nl_msg_cat_cntr; 677 (*foundp)->domain = domain; 678 (*foundp)->translation = retval; 679 (*foundp)->translation_length = retlen; 680 } 681 #endif 682 __set_errno (saved_errno); 683 684 /* Now deal with plural. */ 685 if (plural) 686 retval = plural_lookup (domain, n, retval, retlen); 687 688 __libc_rwlock_unlock (_nl_state_lock); 689 return retval; 690 } 691 } 692 } 693 694 return_untranslated: 695 /* Return the untranslated MSGID. */ 696 FREE_BLOCKS (block_list); 697 __libc_rwlock_unlock (_nl_state_lock); 698 #if 0 /* Doesn't work with diet libc -- TYT */ 699 #ifndef _LIBC 700 if (!ENABLE_SECURE) 701 { 702 extern void _nl_log_untranslated (const char *logfilename, 703 const char *domainname, 704 const char *msgid1, const char *msgid2, 705 int plural); 706 const char *logfilename = getenv ("GETTEXT_LOG_UNTRANSLATED"); 707 708 if (logfilename != NULL && logfilename[0] != '\0') 709 _nl_log_untranslated (logfilename, domainname, msgid1, msgid2, plural); 710 } 711 #endif 712 #endif 713 __set_errno (saved_errno); 714 return (plural == 0 715 ? (char *) msgid1 716 /* Use the Germanic plural rule. */ 717 : n == 1 ? (char *) msgid1 : (char *) msgid2); 718 } 719 720 721 char * 722 internal_function 723 _nl_find_msg (struct loaded_l10nfile *domain_file, 724 struct binding *domainbinding, const char *msgid, 725 size_t *lengthp) 726 { 727 struct loaded_domain *domain; 728 nls_uint32 nstrings; 729 size_t act; 730 char *result; 731 size_t resultlen; 732 733 if (domain_file->decided == 0) 734 _nl_load_domain (domain_file, domainbinding); 735 736 if (domain_file->data == NULL) 737 return NULL; 738 739 domain = (struct loaded_domain *) domain_file->data; 740 741 nstrings = domain->nstrings; 742 743 /* Locate the MSGID and its translation. */ 744 if (domain->hash_tab != NULL) 745 { 746 /* Use the hashing table. */ 747 nls_uint32 len = strlen (msgid); 748 nls_uint32 hash_val = hash_string (msgid); 749 nls_uint32 idx = hash_val % domain->hash_size; 750 nls_uint32 incr = 1 + (hash_val % (domain->hash_size - 2)); 751 752 while (1) 753 { 754 nls_uint32 nstr = 755 W (domain->must_swap_hash_tab, domain->hash_tab[idx]); 756 757 if (nstr == 0) 758 /* Hash table entry is empty. */ 759 return NULL; 760 761 nstr--; 762 763 /* Compare msgid with the original string at index nstr. 764 We compare the lengths with >=, not ==, because plural entries 765 are represented by strings with an embedded NUL. */ 766 if (nstr < nstrings 767 ? W (domain->must_swap, domain->orig_tab[nstr].length) >= len 768 && (strcmp (msgid, 769 domain->data + W (domain->must_swap, 770 domain->orig_tab[nstr].offset)) 771 == 0) 772 : domain->orig_sysdep_tab[nstr - nstrings].length > len 773 && (strcmp (msgid, 774 domain->orig_sysdep_tab[nstr - nstrings].pointer) 775 == 0)) 776 { 777 act = nstr; 778 goto found; 779 } 780 781 if (idx >= domain->hash_size - incr) 782 idx -= domain->hash_size - incr; 783 else 784 idx += incr; 785 } 786 /* NOTREACHED */ 787 } 788 else 789 { 790 /* Try the default method: binary search in the sorted array of 791 messages. */ 792 size_t top, bottom; 793 794 bottom = 0; 795 top = nstrings; 796 while (bottom < top) 797 { 798 int cmp_val; 799 800 act = (bottom + top) / 2; 801 cmp_val = strcmp (msgid, (domain->data 802 + W (domain->must_swap, 803 domain->orig_tab[act].offset))); 804 if (cmp_val < 0) 805 top = act; 806 else if (cmp_val > 0) 807 bottom = act + 1; 808 else 809 goto found; 810 } 811 /* No translation was found. */ 812 return NULL; 813 } 814 815 found: 816 /* The translation was found at index ACT. If we have to convert the 817 string to use a different character set, this is the time. */ 818 if (act < nstrings) 819 { 820 result = (char *) 821 (domain->data + W (domain->must_swap, domain->trans_tab[act].offset)); 822 resultlen = W (domain->must_swap, domain->trans_tab[act].length) + 1; 823 } 824 else 825 { 826 result = (char *) domain->trans_sysdep_tab[act - nstrings].pointer; 827 resultlen = domain->trans_sysdep_tab[act - nstrings].length; 828 } 829 830 #if defined _LIBC || HAVE_ICONV 831 if (domain->codeset_cntr 832 != (domainbinding != NULL ? domainbinding->codeset_cntr : 0)) 833 { 834 /* The domain's codeset has changed through bind_textdomain_codeset() 835 since the message catalog was initialized or last accessed. We 836 have to reinitialize the converter. */ 837 _nl_free_domain_conv (domain); 838 _nl_init_domain_conv (domain_file, domain, domainbinding); 839 } 840 841 if ( 842 # ifdef _LIBC 843 domain->conv != (__gconv_t) -1 844 # else 845 # if HAVE_ICONV 846 domain->conv != (iconv_t) -1 847 # endif 848 # endif 849 ) 850 { 851 /* We are supposed to do a conversion. First allocate an 852 appropriate table with the same structure as the table 853 of translations in the file, where we can put the pointers 854 to the converted strings in. 855 There is a slight complication with plural entries. They 856 are represented by consecutive NUL terminated strings. We 857 handle this case by converting RESULTLEN bytes, including 858 NULs. */ 859 860 if (domain->conv_tab == NULL 861 && ((domain->conv_tab = 862 (char **) calloc (nstrings + domain->n_sysdep_strings, 863 sizeof (char *))) 864 == NULL)) 865 /* Mark that we didn't succeed allocating a table. */ 866 domain->conv_tab = (char **) -1; 867 868 if (__builtin_expect (domain->conv_tab == (char **) -1, 0)) 869 /* Nothing we can do, no more memory. */ 870 goto converted; 871 872 if (domain->conv_tab[act] == NULL) 873 { 874 /* We haven't used this string so far, so it is not 875 translated yet. Do this now. */ 876 /* We use a bit more efficient memory handling. 877 We allocate always larger blocks which get used over 878 time. This is faster than many small allocations. */ 879 __libc_lock_define_initialized (static, lock) 880 # define INITIAL_BLOCK_SIZE 4080 881 static unsigned char *freemem; 882 static size_t freemem_size; 883 884 const unsigned char *inbuf; 885 unsigned char *outbuf; 886 int malloc_count; 887 # ifndef _LIBC 888 transmem_block_t *transmem_list = NULL; 889 # endif 890 891 __libc_lock_lock (lock); 892 893 inbuf = (const unsigned char *) result; 894 outbuf = freemem + sizeof (size_t); 895 896 malloc_count = 0; 897 while (1) 898 { 899 transmem_block_t *newmem; 900 # ifdef _LIBC 901 size_t non_reversible; 902 int res; 903 904 if (freemem_size < sizeof (size_t)) 905 goto resize_freemem; 906 907 res = __gconv (domain->conv, 908 &inbuf, inbuf + resultlen, 909 &outbuf, 910 outbuf + freemem_size - sizeof (size_t), 911 &non_reversible); 912 913 if (res == __GCONV_OK || res == __GCONV_EMPTY_INPUT) 914 break; 915 916 if (res != __GCONV_FULL_OUTPUT) 917 { 918 __libc_lock_unlock (lock); 919 goto converted; 920 } 921 922 inbuf = result; 923 # else 924 # if HAVE_ICONV 925 const char *inptr = (const char *) inbuf; 926 size_t inleft = resultlen; 927 char *outptr = (char *) outbuf; 928 size_t outleft; 929 930 if (freemem_size < sizeof (size_t)) 931 goto resize_freemem; 932 933 outleft = freemem_size - sizeof (size_t); 934 if (iconv (domain->conv, 935 (ICONV_CONST char **) &inptr, &inleft, 936 &outptr, &outleft) 937 != (size_t) (-1)) 938 { 939 outbuf = (unsigned char *) outptr; 940 break; 941 } 942 if (errno != E2BIG) 943 { 944 __libc_lock_unlock (lock); 945 goto converted; 946 } 947 # endif 948 # endif 949 950 resize_freemem: 951 /* We must allocate a new buffer or resize the old one. */ 952 if (malloc_count > 0) 953 { 954 ++malloc_count; 955 freemem_size = malloc_count * INITIAL_BLOCK_SIZE; 956 newmem = (transmem_block_t *) realloc (transmem_list, 957 freemem_size); 958 # ifdef _LIBC 959 if (newmem != NULL) 960 transmem_list = transmem_list->next; 961 else 962 { 963 struct transmem_list *old = transmem_list; 964 965 transmem_list = transmem_list->next; 966 free (old); 967 } 968 # endif 969 } 970 else 971 { 972 malloc_count = 1; 973 freemem_size = INITIAL_BLOCK_SIZE; 974 newmem = (transmem_block_t *) malloc (freemem_size); 975 } 976 if (__builtin_expect (newmem == NULL, 0)) 977 { 978 freemem = NULL; 979 freemem_size = 0; 980 __libc_lock_unlock (lock); 981 goto converted; 982 } 983 984 # ifdef _LIBC 985 /* Add the block to the list of blocks we have to free 986 at some point. */ 987 newmem->next = transmem_list; 988 transmem_list = newmem; 989 990 freemem = newmem->data; 991 freemem_size -= offsetof (struct transmem_list, data); 992 # else 993 transmem_list = newmem; 994 freemem = newmem; 995 # endif 996 997 outbuf = freemem + sizeof (size_t); 998 } 999 1000 /* We have now in our buffer a converted string. Put this 1001 into the table of conversions. */ 1002 *(size_t *) freemem = outbuf - freemem - sizeof (size_t); 1003 domain->conv_tab[act] = (char *) freemem; 1004 /* Shrink freemem, but keep it aligned. */ 1005 freemem_size -= outbuf - freemem; 1006 freemem = outbuf; 1007 freemem += freemem_size & (alignof (size_t) - 1); 1008 freemem_size = freemem_size & ~ (alignof (size_t) - 1); 1009 1010 __libc_lock_unlock (lock); 1011 } 1012 1013 /* Now domain->conv_tab[act] contains the translation of all 1014 the plural variants. */ 1015 result = domain->conv_tab[act] + sizeof (size_t); 1016 resultlen = *(size_t *) domain->conv_tab[act]; 1017 } 1018 1019 converted: 1020 /* The result string is converted. */ 1021 1022 #endif /* _LIBC || HAVE_ICONV */ 1023 1024 *lengthp = resultlen; 1025 return result; 1026 } 1027 1028 1029 /* Look up a plural variant. */ 1030 static char * 1031 internal_function 1032 plural_lookup (struct loaded_l10nfile *domain, unsigned long int n, 1033 const char *translation, size_t translation_len) 1034 { 1035 struct loaded_domain *domaindata = (struct loaded_domain *) domain->data; 1036 unsigned long int index; 1037 const char *p; 1038 1039 index = plural_eval (domaindata->plural, n); 1040 if (index >= domaindata->nplurals) 1041 /* This should never happen. It means the plural expression and the 1042 given maximum value do not match. */ 1043 index = 0; 1044 1045 /* Skip INDEX strings at TRANSLATION. */ 1046 p = translation; 1047 while (index-- > 0) 1048 { 1049 #ifdef _LIBC 1050 p = __rawmemchr (p, '\0'); 1051 #else 1052 p = strchr (p, '\0'); 1053 #endif 1054 /* And skip over the NUL byte. */ 1055 p++; 1056 1057 if (p >= translation + translation_len) 1058 /* This should never happen. It means the plural expression 1059 evaluated to a value larger than the number of variants 1060 available for MSGID1. */ 1061 return (char *) translation; 1062 } 1063 return (char *) p; 1064 } 1065 1066 #ifndef _LIBC 1067 /* Return string representation of locale CATEGORY. */ 1068 static const char * 1069 internal_function 1070 category_to_name (int category) 1071 { 1072 const char *retval; 1073 1074 switch (category) 1075 { 1076 #ifdef LC_COLLATE 1077 case LC_COLLATE: 1078 retval = "LC_COLLATE"; 1079 break; 1080 #endif 1081 #ifdef LC_CTYPE 1082 case LC_CTYPE: 1083 retval = "LC_CTYPE"; 1084 break; 1085 #endif 1086 #ifdef LC_MONETARY 1087 case LC_MONETARY: 1088 retval = "LC_MONETARY"; 1089 break; 1090 #endif 1091 #ifdef LC_NUMERIC 1092 case LC_NUMERIC: 1093 retval = "LC_NUMERIC"; 1094 break; 1095 #endif 1096 #ifdef LC_TIME 1097 case LC_TIME: 1098 retval = "LC_TIME"; 1099 break; 1100 #endif 1101 #ifdef LC_MESSAGES 1102 case LC_MESSAGES: 1103 retval = "LC_MESSAGES"; 1104 break; 1105 #endif 1106 #ifdef LC_RESPONSE 1107 case LC_RESPONSE: 1108 retval = "LC_RESPONSE"; 1109 break; 1110 #endif 1111 #ifdef LC_ALL 1112 case LC_ALL: 1113 /* This might not make sense but is perhaps better than any other 1114 value. */ 1115 retval = "LC_ALL"; 1116 break; 1117 #endif 1118 default: 1119 /* If you have a better idea for a default value let me know. */ 1120 retval = "LC_XXX"; 1121 } 1122 1123 return retval; 1124 } 1125 #endif 1126 1127 /* Guess value of current locale from value of the environment variables. */ 1128 static const char * 1129 internal_function 1130 guess_category_value (int category, const char *categoryname) 1131 { 1132 const char *language; 1133 const char *retval; 1134 1135 /* The highest priority value is the `LANGUAGE' environment 1136 variable. But we don't use the value if the currently selected 1137 locale is the C locale. This is a GNU extension. */ 1138 language = getenv ("LANGUAGE"); 1139 if (language != NULL && language[0] == '\0') 1140 language = NULL; 1141 1142 /* We have to proceed with the POSIX methods of looking to `LC_ALL', 1143 `LC_xxx', and `LANG'. On some systems this can be done by the 1144 `setlocale' function itself. */ 1145 #ifdef _LIBC 1146 retval = __current_locale_name (category); 1147 #else 1148 retval = _nl_locale_name (category, categoryname); 1149 #endif 1150 1151 /* Ignore LANGUAGE if the locale is set to "C" because 1152 1. "C" locale usually uses the ASCII encoding, and most international 1153 messages use non-ASCII characters. These characters get displayed 1154 as question marks (if using glibc's iconv()) or as invalid 8-bit 1155 characters (because other iconv()s refuse to convert most non-ASCII 1156 characters to ASCII). In any case, the output is ugly. 1157 2. The precise output of some programs in the "C" locale is specified 1158 by POSIX and should not depend on environment variables like 1159 "LANGUAGE". We allow such programs to use gettext(). */ 1160 return language != NULL && strcmp (retval, "C") != 0 ? language : retval; 1161 } 1162 1163 /* @@ begin of epilog @@ */ 1164 1165 /* We don't want libintl.a to depend on any other library. So we 1166 avoid the non-standard function stpcpy. In GNU C Library this 1167 function is available, though. Also allow the symbol HAVE_STPCPY 1168 to be defined. */ 1169 #if !_LIBC && !HAVE_STPCPY 1170 static char * 1171 stpcpy (char *dest, const char *src) 1172 { 1173 while ((*dest++ = *src++) != '\0') 1174 /* Do nothing. */ ; 1175 return dest - 1; 1176 } 1177 #endif 1178 1179 #if !_LIBC && !HAVE_MEMPCPY 1180 static void * 1181 mempcpy (void *dest, const void *src, size_t n) 1182 { 1183 return (void *) ((char *) memcpy (dest, src, n) + n); 1184 } 1185 #endif 1186 1187 1188 #ifdef _LIBC 1189 /* If we want to free all resources we have to do some work at 1190 program's end. */ 1191 libc_freeres_fn (free_mem) 1192 { 1193 void *old; 1194 1195 while (_nl_domain_bindings != NULL) 1196 { 1197 struct binding *oldp = _nl_domain_bindings; 1198 _nl_domain_bindings = _nl_domain_bindings->next; 1199 if (oldp->dirname != INTUSE(_nl_default_dirname)) 1200 /* Yes, this is a pointer comparison. */ 1201 free (oldp->dirname); 1202 free (oldp->codeset); 1203 free (oldp); 1204 } 1205 1206 if (_nl_current_default_domain != _nl_default_default_domain) 1207 /* Yes, again a pointer comparison. */ 1208 free ((char *) _nl_current_default_domain); 1209 1210 /* Remove the search tree with the known translations. */ 1211 __tdestroy (root, free); 1212 root = NULL; 1213 1214 while (transmem_list != NULL) 1215 { 1216 old = transmem_list; 1217 transmem_list = transmem_list->next; 1218 free (old); 1219 } 1220 } 1221 #endif 1222
