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