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