intl/loadmsgcat.c

   1 /* Load needed message catalogs.
   2    Copyright (C) 1995-2014 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <http://www.gnu.org/licenses/>.  */
  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 <assert.h>
  31 #include <ctype.h>
  32 #include <errno.h>
  33 #include <fcntl.h>
  34 #include <sys/types.h>
  35 #include <sys/stat.h>
  36
  37 #ifdef __GNUC__
  38 # undef  alloca
  39 # define alloca __builtin_alloca
  40 # define HAVE_ALLOCA 1
  41 #else
  42 # ifdef _MSC_VER
  43 #  include <malloc.h>
  44 #  define alloca _alloca
  45 # else
  46 #  if defined HAVE_ALLOCA_H || defined _LIBC
  47 #   include <alloca.h>
  48 #  else
  49 #   ifdef _AIX
  50  #pragma alloca
  51 #   else
  52 #    ifndef alloca
  53 char *alloca ();
  54 #    endif
  55 #   endif
  56 #  endif
  57 # endif
  58 #endif
  59
  60 #include <stdlib.h>
  61 #include <string.h>
  62
  63 #if defined HAVE_UNISTD_H || defined _LIBC
  64 # include <unistd.h>
  65 #endif
  66
  67 #ifdef _LIBC
  68 # include <langinfo.h>
  69 # include <locale.h>
  70 #endif
  71
  72 #if (defined HAVE_MMAP && defined HAVE_MUNMAP && !defined DISALLOW_MMAP) \
  73     || (defined _LIBC && defined _POSIX_MAPPED_FILES)
  74 # include <sys/mman.h>
  75 # undef HAVE_MMAP
  76 # define HAVE_MMAP      1
  77 #else
  78 # undef HAVE_MMAP
  79 #endif
  80
  81 #if defined HAVE_STDINT_H_WITH_UINTMAX || defined _LIBC
  82 # include <stdint.h>
  83 #endif
  84 #if defined HAVE_INTTYPES_H || defined _LIBC
  85 # include <inttypes.h>
  86 #endif
  87
  88 #include "gmo.h"
  89 #include "gettextP.h"
  90 #include "hash-string.h"
  91 #include "plural-exp.h"
  92
  93 #ifdef _LIBC
  94 # include "../locale/localeinfo.h"
  95 # include <not-cancel.h>
  96 #endif
  97
  98 /* Handle multi-threaded applications.  */
  99 #ifdef _LIBC
 100 # include <bits/libc-lock.h>
 101 #else
 102 # include "lock.h"
 103 #endif
 104
 105 #ifdef _LIBC
 106 # define PRI_MACROS_BROKEN 0
 107 #endif
 108
 109 /* Provide fallback values for macros that ought to be defined in <inttypes.h>.
 110    Note that our fallback values need not be literal strings, because we don't
 111    use them with preprocessor string concatenation.  */
 112 #if !defined PRId8 || PRI_MACROS_BROKEN
 113 # undef PRId8
 114 # define PRId8 "d"
 115 #endif
 116 #if !defined PRIi8 || PRI_MACROS_BROKEN
 117 # undef PRIi8
 118 # define PRIi8 "i"
 119 #endif
 120 #if !defined PRIo8 || PRI_MACROS_BROKEN
 121 # undef PRIo8
 122 # define PRIo8 "o"
 123 #endif
 124 #if !defined PRIu8 || PRI_MACROS_BROKEN
 125 # undef PRIu8
 126 # define PRIu8 "u"
 127 #endif
 128 #if !defined PRIx8 || PRI_MACROS_BROKEN
 129 # undef PRIx8
 130 # define PRIx8 "x"
 131 #endif
 132 #if !defined PRIX8 || PRI_MACROS_BROKEN
 133 # undef PRIX8
 134 # define PRIX8 "X"
 135 #endif
 136 #if !defined PRId16 || PRI_MACROS_BROKEN
 137 # undef PRId16
 138 # define PRId16 "d"
 139 #endif
 140 #if !defined PRIi16 || PRI_MACROS_BROKEN
 141 # undef PRIi16
 142 # define PRIi16 "i"
 143 #endif
 144 #if !defined PRIo16 || PRI_MACROS_BROKEN
 145 # undef PRIo16
 146 # define PRIo16 "o"
 147 #endif
 148 #if !defined PRIu16 || PRI_MACROS_BROKEN
 149 # undef PRIu16
 150 # define PRIu16 "u"
 151 #endif
 152 #if !defined PRIx16 || PRI_MACROS_BROKEN
 153 # undef PRIx16
 154 # define PRIx16 "x"
 155 #endif
 156 #if !defined PRIX16 || PRI_MACROS_BROKEN
 157 # undef PRIX16
 158 # define PRIX16 "X"
 159 #endif
 160 #if !defined PRId32 || PRI_MACROS_BROKEN
 161 # undef PRId32
 162 # define PRId32 "d"
 163 #endif
 164 #if !defined PRIi32 || PRI_MACROS_BROKEN
 165 # undef PRIi32
 166 # define PRIi32 "i"
 167 #endif
 168 #if !defined PRIo32 || PRI_MACROS_BROKEN
 169 # undef PRIo32
 170 # define PRIo32 "o"
 171 #endif
 172 #if !defined PRIu32 || PRI_MACROS_BROKEN
 173 # undef PRIu32
 174 # define PRIu32 "u"
 175 #endif
 176 #if !defined PRIx32 || PRI_MACROS_BROKEN
 177 # undef PRIx32
 178 # define PRIx32 "x"
 179 #endif
 180 #if !defined PRIX32 || PRI_MACROS_BROKEN
 181 # undef PRIX32
 182 # define PRIX32 "X"
 183 #endif
 184 #if !defined PRId64 || PRI_MACROS_BROKEN
 185 # undef PRId64
 186 # define PRId64 (sizeof (long) == 8 ? "ld" : "lld")
 187 #endif
 188 #if !defined PRIi64 || PRI_MACROS_BROKEN
 189 # undef PRIi64
 190 # define PRIi64 (sizeof (long) == 8 ? "li" : "lli")
 191 #endif
 192 #if !defined PRIo64 || PRI_MACROS_BROKEN
 193 # undef PRIo64
 194 # define PRIo64 (sizeof (long) == 8 ? "lo" : "llo")
 195 #endif
 196 #if !defined PRIu64 || PRI_MACROS_BROKEN
 197 # undef PRIu64
 198 # define PRIu64 (sizeof (long) == 8 ? "lu" : "llu")
 199 #endif
 200 #if !defined PRIx64 || PRI_MACROS_BROKEN
 201 # undef PRIx64
 202 # define PRIx64 (sizeof (long) == 8 ? "lx" : "llx")
 203 #endif
 204 #if !defined PRIX64 || PRI_MACROS_BROKEN
 205 # undef PRIX64
 206 # define PRIX64 (sizeof (long) == 8 ? "lX" : "llX")
 207 #endif
 208 #if !defined PRIdLEAST8 || PRI_MACROS_BROKEN
 209 # undef PRIdLEAST8
 210 # define PRIdLEAST8 "d"
 211 #endif
 212 #if !defined PRIiLEAST8 || PRI_MACROS_BROKEN
 213 # undef PRIiLEAST8
 214 # define PRIiLEAST8 "i"
 215 #endif
 216 #if !defined PRIoLEAST8 || PRI_MACROS_BROKEN
 217 # undef PRIoLEAST8
 218 # define PRIoLEAST8 "o"
 219 #endif
 220 #if !defined PRIuLEAST8 || PRI_MACROS_BROKEN
 221 # undef PRIuLEAST8
 222 # define PRIuLEAST8 "u"
 223 #endif
 224 #if !defined PRIxLEAST8 || PRI_MACROS_BROKEN
 225 # undef PRIxLEAST8
 226 # define PRIxLEAST8 "x"
 227 #endif
 228 #if !defined PRIXLEAST8 || PRI_MACROS_BROKEN
 229 # undef PRIXLEAST8
 230 # define PRIXLEAST8 "X"
 231 #endif
 232 #if !defined PRIdLEAST16 || PRI_MACROS_BROKEN
 233 # undef PRIdLEAST16
 234 # define PRIdLEAST16 "d"
 235 #endif
 236 #if !defined PRIiLEAST16 || PRI_MACROS_BROKEN
 237 # undef PRIiLEAST16
 238 # define PRIiLEAST16 "i"
 239 #endif
 240 #if !defined PRIoLEAST16 || PRI_MACROS_BROKEN
 241 # undef PRIoLEAST16
 242 # define PRIoLEAST16 "o"
 243 #endif
 244 #if !defined PRIuLEAST16 || PRI_MACROS_BROKEN
 245 # undef PRIuLEAST16
 246 # define PRIuLEAST16 "u"
 247 #endif
 248 #if !defined PRIxLEAST16 || PRI_MACROS_BROKEN
 249 # undef PRIxLEAST16
 250 # define PRIxLEAST16 "x"
 251 #endif
 252 #if !defined PRIXLEAST16 || PRI_MACROS_BROKEN
 253 # undef PRIXLEAST16
 254 # define PRIXLEAST16 "X"
 255 #endif
 256 #if !defined PRIdLEAST32 || PRI_MACROS_BROKEN
 257 # undef PRIdLEAST32
 258 # define PRIdLEAST32 "d"
 259 #endif
 260 #if !defined PRIiLEAST32 || PRI_MACROS_BROKEN
 261 # undef PRIiLEAST32
 262 # define PRIiLEAST32 "i"
 263 #endif
 264 #if !defined PRIoLEAST32 || PRI_MACROS_BROKEN
 265 # undef PRIoLEAST32
 266 # define PRIoLEAST32 "o"
 267 #endif
 268 #if !defined PRIuLEAST32 || PRI_MACROS_BROKEN
 269 # undef PRIuLEAST32
 270 # define PRIuLEAST32 "u"
 271 #endif
 272 #if !defined PRIxLEAST32 || PRI_MACROS_BROKEN
 273 # undef PRIxLEAST32
 274 # define PRIxLEAST32 "x"
 275 #endif
 276 #if !defined PRIXLEAST32 || PRI_MACROS_BROKEN
 277 # undef PRIXLEAST32
 278 # define PRIXLEAST32 "X"
 279 #endif
 280 #if !defined PRIdLEAST64 || PRI_MACROS_BROKEN
 281 # undef PRIdLEAST64
 282 # define PRIdLEAST64 PRId64
 283 #endif
 284 #if !defined PRIiLEAST64 || PRI_MACROS_BROKEN
 285 # undef PRIiLEAST64
 286 # define PRIiLEAST64 PRIi64
 287 #endif
 288 #if !defined PRIoLEAST64 || PRI_MACROS_BROKEN
 289 # undef PRIoLEAST64
 290 # define PRIoLEAST64 PRIo64
 291 #endif
 292 #if !defined PRIuLEAST64 || PRI_MACROS_BROKEN
 293 # undef PRIuLEAST64
 294 # define PRIuLEAST64 PRIu64
 295 #endif
 296 #if !defined PRIxLEAST64 || PRI_MACROS_BROKEN
 297 # undef PRIxLEAST64
 298 # define PRIxLEAST64 PRIx64
 299 #endif
 300 #if !defined PRIXLEAST64 || PRI_MACROS_BROKEN
 301 # undef PRIXLEAST64
 302 # define PRIXLEAST64 PRIX64
 303 #endif
 304 #if !defined PRIdFAST8 || PRI_MACROS_BROKEN
 305 # undef PRIdFAST8
 306 # define PRIdFAST8 "d"
 307 #endif
 308 #if !defined PRIiFAST8 || PRI_MACROS_BROKEN
 309 # undef PRIiFAST8
 310 # define PRIiFAST8 "i"
 311 #endif
 312 #if !defined PRIoFAST8 || PRI_MACROS_BROKEN
 313 # undef PRIoFAST8
 314 # define PRIoFAST8 "o"
 315 #endif
 316 #if !defined PRIuFAST8 || PRI_MACROS_BROKEN
 317 # undef PRIuFAST8
 318 # define PRIuFAST8 "u"
 319 #endif
 320 #if !defined PRIxFAST8 || PRI_MACROS_BROKEN
 321 # undef PRIxFAST8
 322 # define PRIxFAST8 "x"
 323 #endif
 324 #if !defined PRIXFAST8 || PRI_MACROS_BROKEN
 325 # undef PRIXFAST8
 326 # define PRIXFAST8 "X"
 327 #endif
 328 #if !defined PRIdFAST16 || PRI_MACROS_BROKEN
 329 # undef PRIdFAST16
 330 # define PRIdFAST16 "d"
 331 #endif
 332 #if !defined PRIiFAST16 || PRI_MACROS_BROKEN
 333 # undef PRIiFAST16
 334 # define PRIiFAST16 "i"
 335 #endif
 336 #if !defined PRIoFAST16 || PRI_MACROS_BROKEN
 337 # undef PRIoFAST16
 338 # define PRIoFAST16 "o"
 339 #endif
 340 #if !defined PRIuFAST16 || PRI_MACROS_BROKEN
 341 # undef PRIuFAST16
 342 # define PRIuFAST16 "u"
 343 #endif
 344 #if !defined PRIxFAST16 || PRI_MACROS_BROKEN
 345 # undef PRIxFAST16
 346 # define PRIxFAST16 "x"
 347 #endif
 348 #if !defined PRIXFAST16 || PRI_MACROS_BROKEN
 349 # undef PRIXFAST16
 350 # define PRIXFAST16 "X"
 351 #endif
 352 #if !defined PRIdFAST32 || PRI_MACROS_BROKEN
 353 # undef PRIdFAST32
 354 # define PRIdFAST32 "d"
 355 #endif
 356 #if !defined PRIiFAST32 || PRI_MACROS_BROKEN
 357 # undef PRIiFAST32
 358 # define PRIiFAST32 "i"
 359 #endif
 360 #if !defined PRIoFAST32 || PRI_MACROS_BROKEN
 361 # undef PRIoFAST32
 362 # define PRIoFAST32 "o"
 363 #endif
 364 #if !defined PRIuFAST32 || PRI_MACROS_BROKEN
 365 # undef PRIuFAST32
 366 # define PRIuFAST32 "u"
 367 #endif
 368 #if !defined PRIxFAST32 || PRI_MACROS_BROKEN
 369 # undef PRIxFAST32
 370 # define PRIxFAST32 "x"
 371 #endif
 372 #if !defined PRIXFAST32 || PRI_MACROS_BROKEN
 373 # undef PRIXFAST32
 374 # define PRIXFAST32 "X"
 375 #endif
 376 #if !defined PRIdFAST64 || PRI_MACROS_BROKEN
 377 # undef PRIdFAST64
 378 # define PRIdFAST64 PRId64
 379 #endif
 380 #if !defined PRIiFAST64 || PRI_MACROS_BROKEN
 381 # undef PRIiFAST64
 382 # define PRIiFAST64 PRIi64
 383 #endif
 384 #if !defined PRIoFAST64 || PRI_MACROS_BROKEN
 385 # undef PRIoFAST64
 386 # define PRIoFAST64 PRIo64
 387 #endif
 388 #if !defined PRIuFAST64 || PRI_MACROS_BROKEN
 389 # undef PRIuFAST64
 390 # define PRIuFAST64 PRIu64
 391 #endif
 392 #if !defined PRIxFAST64 || PRI_MACROS_BROKEN
 393 # undef PRIxFAST64
 394 # define PRIxFAST64 PRIx64
 395 #endif
 396 #if !defined PRIXFAST64 || PRI_MACROS_BROKEN
 397 # undef PRIXFAST64
 398 # define PRIXFAST64 PRIX64
 399 #endif
 400 #if !defined PRIdMAX || PRI_MACROS_BROKEN
 401 # undef PRIdMAX
 402 # define PRIdMAX (sizeof (uintmax_t) == sizeof (long) ? "ld" : "lld")
 403 #endif
 404 #if !defined PRIiMAX || PRI_MACROS_BROKEN
 405 # undef PRIiMAX
 406 # define PRIiMAX (sizeof (uintmax_t) == sizeof (long) ? "li" : "lli")
 407 #endif
 408 #if !defined PRIoMAX || PRI_MACROS_BROKEN
 409 # undef PRIoMAX
 410 # define PRIoMAX (sizeof (uintmax_t) == sizeof (long) ? "lo" : "llo")
 411 #endif
 412 #if !defined PRIuMAX || PRI_MACROS_BROKEN
 413 # undef PRIuMAX
 414 # define PRIuMAX (sizeof (uintmax_t) == sizeof (long) ? "lu" : "llu")
 415 #endif
 416 #if !defined PRIxMAX || PRI_MACROS_BROKEN
 417 # undef PRIxMAX
 418 # define PRIxMAX (sizeof (uintmax_t) == sizeof (long) ? "lx" : "llx")
 419 #endif
 420 #if !defined PRIXMAX || PRI_MACROS_BROKEN
 421 # undef PRIXMAX
 422 # define PRIXMAX (sizeof (uintmax_t) == sizeof (long) ? "lX" : "llX")
 423 #endif
 424 #if !defined PRIdPTR || PRI_MACROS_BROKEN
 425 # undef PRIdPTR
 426 # define PRIdPTR \
 427   (sizeof (void *) == sizeof (long) ? "ld" : \
 428    sizeof (void *) == sizeof (int) ? "d" : \
 429    "lld")
 430 #endif
 431 #if !defined PRIiPTR || PRI_MACROS_BROKEN
 432 # undef PRIiPTR
 433 # define PRIiPTR \
 434   (sizeof (void *) == sizeof (long) ? "li" : \
 435    sizeof (void *) == sizeof (int) ? "i" : \
 436    "lli")
 437 #endif
 438 #if !defined PRIoPTR || PRI_MACROS_BROKEN
 439 # undef PRIoPTR
 440 # define PRIoPTR \
 441   (sizeof (void *) == sizeof (long) ? "lo" : \
 442    sizeof (void *) == sizeof (int) ? "o" : \
 443    "llo")
 444 #endif
 445 #if !defined PRIuPTR || PRI_MACROS_BROKEN
 446 # undef PRIuPTR
 447 # define PRIuPTR \
 448   (sizeof (void *) == sizeof (long) ? "lu" : \
 449    sizeof (void *) == sizeof (int) ? "u" : \
 450    "llu")
 451 #endif
 452 #if !defined PRIxPTR || PRI_MACROS_BROKEN
 453 # undef PRIxPTR
 454 # define PRIxPTR \
 455   (sizeof (void *) == sizeof (long) ? "lx" : \
 456    sizeof (void *) == sizeof (int) ? "x" : \
 457    "llx")
 458 #endif
 459 #if !defined PRIXPTR || PRI_MACROS_BROKEN
 460 # undef PRIXPTR
 461 # define PRIXPTR \
 462   (sizeof (void *) == sizeof (long) ? "lX" : \
 463    sizeof (void *) == sizeof (int) ? "X" : \
 464    "llX")
 465 #endif
 466
 467 /* @@ end of prolog @@ */
 468
 469 #ifdef _LIBC
 470 /* Rename the non ISO C functions.  This is required by the standard
 471    because some ISO C functions will require linking with this object
 472    file and the name space must not be polluted.  */
 473 # define open(name, flags)      open_not_cancel_2 (name, flags)
 474 # define close(fd)              close_not_cancel_no_status (fd)
 475 # define read(fd, buf, n)       read_not_cancel (fd, buf, n)
 476 # define mmap(addr, len, prot, flags, fd, offset) \
 477   __mmap (addr, len, prot, flags, fd, offset)
 478 # define munmap(addr, len)      __munmap (addr, len)
 479 #endif
 480
 481 /* For those losing systems which don't have `alloca' we have to add
 482    some additional code emulating it.  */
 483 #ifdef HAVE_ALLOCA
 484 # define freea(p) /* nothing */
 485 #else
 486 # define alloca(n) malloc (n)
 487 # define freea(p) free (p)
 488 #endif
 489
 490 /* For systems that distinguish between text and binary I/O.
 491    O_BINARY is usually declared in <fcntl.h>. */
 492 #if !defined O_BINARY && defined _O_BINARY
 493   /* For MSC-compatible compilers.  */
 494 # define O_BINARY _O_BINARY
 495 # define O_TEXT _O_TEXT
 496 #endif
 497 #ifdef __BEOS__
 498   /* BeOS 5 has O_BINARY and O_TEXT, but they have no effect.  */
 499 # undef O_BINARY
 500 # undef O_TEXT
 501 #endif
 502 /* On reasonable systems, binary I/O is the default.  */
 503 #ifndef O_BINARY
 504 # define O_BINARY 0
 505 #endif
 506
 507
 508 /* We need a sign, whether a new catalog was loaded, which can be associated
 509    with all translations.  This is important if the translations are
 510    cached by one of GCC's features.  */
 511 int _nl_msg_cat_cntr;
 512
 513
 514 /* Expand a system dependent string segment.  Return NULL if unsupported.  */
 515 static const char *
 516 get_sysdep_segment_value (const char *name)
 517 {
 518   /* Test for an ISO C 99 section 7.8.1 format string directive.
 519      Syntax:
 520      P R I { d | i | o | u | x | X }
 521      { { | LEAST | FAST } { 8 | 16 | 32 | 64 } | MAX | PTR }  */
 522   /* We don't use a table of 14 times 6 'const char *' strings here, because
 523      data relocations cost startup time.  */
 524   if (name[0] == 'P' && name[1] == 'R' && name[2] == 'I')
 525     {
 526       if (name[3] == 'd' || name[3] == 'i' || name[3] == 'o' || name[3] == 'u'
 527           || name[3] == 'x' || name[3] == 'X')
 528         {
 529           if (name[4] == '8' && name[5] == '\0')
 530             {
 531               if (name[3] == 'd')
 532                 return PRId8;
 533               if (name[3] == 'i')
 534                 return PRIi8;
 535               if (name[3] == 'o')
 536                 return PRIo8;
 537               if (name[3] == 'u')
 538                 return PRIu8;
 539               if (name[3] == 'x')
 540                 return PRIx8;
 541               if (name[3] == 'X')
 542                 return PRIX8;
 543               abort ();
 544             }
 545           if (name[4] == '1' && name[5] == '6' && name[6] == '\0')
 546             {
 547               if (name[3] == 'd')
 548                 return PRId16;
 549               if (name[3] == 'i')
 550                 return PRIi16;
 551               if (name[3] == 'o')
 552                 return PRIo16;
 553               if (name[3] == 'u')
 554                 return PRIu16;
 555               if (name[3] == 'x')
 556                 return PRIx16;
 557               if (name[3] == 'X')
 558                 return PRIX16;
 559               abort ();
 560             }
 561           if (name[4] == '3' && name[5] == '2' && name[6] == '\0')
 562             {
 563               if (name[3] == 'd')
 564                 return PRId32;
 565               if (name[3] == 'i')
 566                 return PRIi32;
 567               if (name[3] == 'o')
 568                 return PRIo32;
 569               if (name[3] == 'u')
 570                 return PRIu32;
 571               if (name[3] == 'x')
 572                 return PRIx32;
 573               if (name[3] == 'X')
 574                 return PRIX32;
 575               abort ();
 576             }
 577           if (name[4] == '6' && name[5] == '4' && name[6] == '\0')
 578             {
 579               if (name[3] == 'd')
 580                 return PRId64;
 581               if (name[3] == 'i')
 582                 return PRIi64;
 583               if (name[3] == 'o')
 584                 return PRIo64;
 585               if (name[3] == 'u')
 586                 return PRIu64;
 587               if (name[3] == 'x')
 588                 return PRIx64;
 589               if (name[3] == 'X')
 590                 return PRIX64;
 591               abort ();
 592             }
 593           if (name[4] == 'L' && name[5] == 'E' && name[6] == 'A'
 594               && name[7] == 'S' && name[8] == 'T')
 595             {
 596               if (name[9] == '8' && name[10] == '\0')
 597                 {
 598                   if (name[3] == 'd')
 599                     return PRIdLEAST8;
 600                   if (name[3] == 'i')
 601                     return PRIiLEAST8;
 602                   if (name[3] == 'o')
 603                     return PRIoLEAST8;
 604                   if (name[3] == 'u')
 605                     return PRIuLEAST8;
 606                   if (name[3] == 'x')
 607                     return PRIxLEAST8;
 608                   if (name[3] == 'X')
 609                     return PRIXLEAST8;
 610                   abort ();
 611                 }
 612               if (name[9] == '1' && name[10] == '6' && name[11] == '\0')
 613                 {
 614                   if (name[3] == 'd')
 615                     return PRIdLEAST16;
 616                   if (name[3] == 'i')
 617                     return PRIiLEAST16;
 618                   if (name[3] == 'o')
 619                     return PRIoLEAST16;
 620                   if (name[3] == 'u')
 621                     return PRIuLEAST16;
 622                   if (name[3] == 'x')
 623                     return PRIxLEAST16;
 624                   if (name[3] == 'X')
 625                     return PRIXLEAST16;
 626                   abort ();
 627                 }
 628               if (name[9] == '3' && name[10] == '2' && name[11] == '\0')
 629                 {
 630                   if (name[3] == 'd')
 631                     return PRIdLEAST32;
 632                   if (name[3] == 'i')
 633                     return PRIiLEAST32;
 634                   if (name[3] == 'o')
 635                     return PRIoLEAST32;
 636                   if (name[3] == 'u')
 637                     return PRIuLEAST32;
 638                   if (name[3] == 'x')
 639                     return PRIxLEAST32;
 640                   if (name[3] == 'X')
 641                     return PRIXLEAST32;
 642                   abort ();
 643                 }
 644               if (name[9] == '6' && name[10] == '4' && name[11] == '\0')
 645                 {
 646                   if (name[3] == 'd')
 647                     return PRIdLEAST64;
 648                   if (name[3] == 'i')
 649                     return PRIiLEAST64;
 650                   if (name[3] == 'o')
 651                     return PRIoLEAST64;
 652                   if (name[3] == 'u')
 653                     return PRIuLEAST64;
 654                   if (name[3] == 'x')
 655                     return PRIxLEAST64;
 656                   if (name[3] == 'X')
 657                     return PRIXLEAST64;
 658                   abort ();
 659                 }
 660             }
 661           if (name[4] == 'F' && name[5] == 'A' && name[6] == 'S'
 662               && name[7] == 'T')
 663             {
 664               if (name[8] == '8' && name[9] == '\0')
 665                 {
 666                   if (name[3] == 'd')
 667                     return PRIdFAST8;
 668                   if (name[3] == 'i')
 669                     return PRIiFAST8;
 670                   if (name[3] == 'o')
 671                     return PRIoFAST8;
 672                   if (name[3] == 'u')
 673                     return PRIuFAST8;
 674                   if (name[3] == 'x')
 675                     return PRIxFAST8;
 676                   if (name[3] == 'X')
 677                     return PRIXFAST8;
 678                   abort ();
 679                 }
 680               if (name[8] == '1' && name[9] == '6' && name[10] == '\0')
 681                 {
 682                   if (name[3] == 'd')
 683                     return PRIdFAST16;
 684                   if (name[3] == 'i')
 685                     return PRIiFAST16;
 686                   if (name[3] == 'o')
 687                     return PRIoFAST16;
 688                   if (name[3] == 'u')
 689                     return PRIuFAST16;
 690                   if (name[3] == 'x')
 691                     return PRIxFAST16;
 692                   if (name[3] == 'X')
 693                     return PRIXFAST16;
 694                   abort ();
 695                 }
 696               if (name[8] == '3' && name[9] == '2' && name[10] == '\0')
 697                 {
 698                   if (name[3] == 'd')
 699                     return PRIdFAST32;
 700                   if (name[3] == 'i')
 701                     return PRIiFAST32;
 702                   if (name[3] == 'o')
 703                     return PRIoFAST32;
 704                   if (name[3] == 'u')
 705                     return PRIuFAST32;
 706                   if (name[3] == 'x')
 707                     return PRIxFAST32;
 708                   if (name[3] == 'X')
 709                     return PRIXFAST32;
 710                   abort ();
 711                 }
 712               if (name[8] == '6' && name[9] == '4' && name[10] == '\0')
 713                 {
 714                   if (name[3] == 'd')
 715                     return PRIdFAST64;
 716                   if (name[3] == 'i')
 717                     return PRIiFAST64;
 718                   if (name[3] == 'o')
 719                     return PRIoFAST64;
 720                   if (name[3] == 'u')
 721                     return PRIuFAST64;
 722                   if (name[3] == 'x')
 723                     return PRIxFAST64;
 724                   if (name[3] == 'X')
 725                     return PRIXFAST64;
 726                   abort ();
 727                 }
 728             }
 729           if (name[4] == 'M' && name[5] == 'A' && name[6] == 'X'
 730               && name[7] == '\0')
 731             {
 732               if (name[3] == 'd')
 733                 return PRIdMAX;
 734               if (name[3] == 'i')
 735                 return PRIiMAX;
 736               if (name[3] == 'o')
 737                 return PRIoMAX;
 738               if (name[3] == 'u')
 739                 return PRIuMAX;
 740               if (name[3] == 'x')
 741                 return PRIxMAX;
 742               if (name[3] == 'X')
 743                 return PRIXMAX;
 744               abort ();
 745             }
 746           if (name[4] == 'P' && name[5] == 'T' && name[6] == 'R'
 747               && name[7] == '\0')
 748             {
 749               if (name[3] == 'd')
 750                 return PRIdPTR;
 751               if (name[3] == 'i')
 752                 return PRIiPTR;
 753               if (name[3] == 'o')
 754                 return PRIoPTR;
 755               if (name[3] == 'u')
 756                 return PRIuPTR;
 757               if (name[3] == 'x')
 758                 return PRIxPTR;
 759               if (name[3] == 'X')
 760                 return PRIXPTR;
 761               abort ();
 762             }
 763         }
 764     }
 765   /* Test for a glibc specific printf() format directive flag.  */
 766   if (name[0] == 'I' && name[1] == '\0')
 767     {
 768 #if defined _LIBC \
 769     || ((__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)) \
 770         && !defined __UCLIBC__)
 771       /* The 'I' flag, in numeric format directives, replaces ASCII digits
 772          with the 'outdigits' defined in the LC_CTYPE locale facet.  This is
 773          used for Farsi (Persian), some Indic languages, and maybe Arabic.  */
 774       return "I";
 775 #else
 776       return "";
 777 #endif
 778     }
 779   /* Other system dependent strings are not valid.  */
 780   return NULL;
 781 }
 782
 783 /* Load the message catalogs specified by FILENAME.  If it is no valid
 784    message catalog do nothing.  */
 785 void
 786 internal_function
 787 _nl_load_domain (struct loaded_l10nfile *domain_file,
 788                  struct binding *domainbinding)
 789 {
 790   __libc_lock_define_initialized_recursive (static, lock);
 791   int fd = -1;
 792   size_t size;
 793 #ifdef _LIBC
 794   struct stat64 st;
 795 #else
 796   struct stat st;
 797 #endif
 798   struct mo_file_header *data = (struct mo_file_header *) -1;
 799   int use_mmap = 0;
 800   struct loaded_domain *domain;
 801   int revision;
 802   const char *nullentry;
 803   size_t nullentrylen;
 804
 805   __libc_lock_lock_recursive (lock);
 806   if (domain_file->decided != 0)
 807     {
 808       /* There are two possibilities:
 809
 810          + this is the same thread calling again during this initialization
 811            via _nl_find_msg.  We have initialized everything this call needs.
 812
 813          + this is another thread which tried to initialize this object.
 814            Not necessary anymore since if the lock is available this
 815            is finished.
 816       */
 817       goto done;
 818     }
 819
 820   domain_file->decided = -1;
 821   domain_file->data = NULL;
 822
 823   /* Note that it would be useless to store domainbinding in domain_file
 824      because domainbinding might be == NULL now but != NULL later (after
 825      a call to bind_textdomain_codeset).  */
 826
 827   /* If the record does not represent a valid locale the FILENAME
 828      might be NULL.  This can happen when according to the given
 829      specification the locale file name is different for XPG and CEN
 830      syntax.  */
 831   if (domain_file->filename == NULL)
 832     goto out;
 833
 834   /* Try to open the addressed file.  */
 835   fd = open (domain_file->filename, O_RDONLY | O_BINARY);
 836   if (fd == -1)
 837     goto out;
 838
 839   /* We must know about the size of the file.  */
 840   if (
 841 #ifdef _LIBC
 842       __builtin_expect (fstat64 (fd, &st) != 0, 0)
 843 #else
 844       __builtin_expect (fstat (fd, &st) != 0, 0)
 845 #endif
 846       || __builtin_expect ((size = (size_t) st.st_size) != st.st_size, 0)
 847       || __builtin_expect (size < sizeof (struct mo_file_header), 0))
 848     /* Something went wrong.  */
 849     goto out;
 850
 851 #ifdef HAVE_MMAP
 852   /* Now we are ready to load the file.  If mmap() is available we try
 853      this first.  If not available or it failed we try to load it.  */
 854   data = (struct mo_file_header *) mmap (NULL, size, PROT_READ,
 855                                          MAP_PRIVATE, fd, 0);
 856
 857   if (__builtin_expect (data != MAP_FAILED, 1))
 858     {
 859       /* mmap() call was successful.  */
 860       close (fd);
 861       fd = -1;
 862       use_mmap = 1;
 863     }
 864
 865   assert (MAP_FAILED == (void *) -1);
 866 #endif
 867
 868   /* If the data is not yet available (i.e. mmap'ed) we try to load
 869      it manually.  */
 870   if (data == (struct mo_file_header *) -1)
 871     {
 872       size_t to_read;
 873       char *read_ptr;
 874
 875       data = (struct mo_file_header *) malloc (size);
 876       if (data == NULL)
 877         goto out;
 878
 879       to_read = size;
 880       read_ptr = (char *) data;
 881       do
 882         {
 883           long int nb = (long int) read (fd, read_ptr, to_read);
 884           if (nb <= 0)
 885             {
 886 #ifdef EINTR
 887               if (nb == -1 && errno == EINTR)
 888                 continue;
 889 #endif
 890               goto out;
 891             }
 892           read_ptr += nb;
 893           to_read -= nb;
 894         }
 895       while (to_read > 0);
 896
 897       close (fd);
 898       fd = -1;
 899     }
 900
 901   /* Using the magic number we can test whether it really is a message
 902      catalog file.  */
 903   if (__builtin_expect (data->magic != _MAGIC && data->magic != _MAGIC_SWAPPED,
 904                         0))
 905     {
 906       /* The magic number is wrong: not a message catalog file.  */
 907 #ifdef HAVE_MMAP
 908       if (use_mmap)
 909         munmap ((caddr_t) data, size);
 910       else
 911 #endif
 912         free (data);
 913       goto out;
 914     }
 915
 916   domain = (struct loaded_domain *) malloc (sizeof (struct loaded_domain));
 917   if (domain == NULL)
 918     goto out;
 919   domain_file->data = domain;
 920
 921   domain->data = (char *) data;
 922   domain->use_mmap = use_mmap;
 923   domain->mmap_size = size;
 924   domain->must_swap = data->magic != _MAGIC;
 925   domain->malloced = NULL;
 926
 927   /* Fill in the information about the available tables.  */
 928   revision = W (domain->must_swap, data->revision);
 929   /* We support only the major revisions 0 and 1.  */
 930   switch (revision >> 16)
 931     {
 932     case 0:
 933     case 1:
 934       domain->nstrings = W (domain->must_swap, data->nstrings);
 935       domain->orig_tab = (const struct string_desc *)
 936         ((char *) data + W (domain->must_swap, data->orig_tab_offset));
 937       domain->trans_tab = (const struct string_desc *)
 938         ((char *) data + W (domain->must_swap, data->trans_tab_offset));
 939       domain->hash_size = W (domain->must_swap, data->hash_tab_size);
 940       domain->hash_tab =
 941         (domain->hash_size > 2
 942          ? (const nls_uint32 *)
 943            ((char *) data + W (domain->must_swap, data->hash_tab_offset))
 944          : NULL);
 945       domain->must_swap_hash_tab = domain->must_swap;
 946
 947       /* Now dispatch on the minor revision.  */
 948       switch (revision & 0xffff)
 949         {
 950         case 0:
 951           domain->n_sysdep_strings = 0;
 952           domain->orig_sysdep_tab = NULL;
 953           domain->trans_sysdep_tab = NULL;
 954           break;
 955         case 1:
 956         default:
 957           {
 958             nls_uint32 n_sysdep_strings;
 959
 960             if (domain->hash_tab == NULL)
 961               /* This is invalid.  These minor revisions need a hash table.  */
 962               goto invalid;
 963
 964             n_sysdep_strings =
 965               W (domain->must_swap, data->n_sysdep_strings);
 966             if (n_sysdep_strings > 0)
 967               {
 968                 nls_uint32 n_sysdep_segments;
 969                 const struct sysdep_segment *sysdep_segments;
 970                 const char **sysdep_segment_values;
 971                 const nls_uint32 *orig_sysdep_tab;
 972                 const nls_uint32 *trans_sysdep_tab;
 973                 nls_uint32 n_inmem_sysdep_strings;
 974                 size_t memneed;
 975                 char *mem;
 976                 struct sysdep_string_desc *inmem_orig_sysdep_tab;
 977                 struct sysdep_string_desc *inmem_trans_sysdep_tab;
 978                 nls_uint32 *inmem_hash_tab;
 979                 unsigned int i, j;
 980
 981                 /* Get the values of the system dependent segments.  */
 982                 n_sysdep_segments =
 983                   W (domain->must_swap, data->n_sysdep_segments);
 984                 sysdep_segments = (const struct sysdep_segment *)
 985                   ((char *) data
 986                    + W (domain->must_swap, data->sysdep_segments_offset));
 987                 sysdep_segment_values =
 988                   (const char **)
 989                   alloca (n_sysdep_segments * sizeof (const char *));
 990                 for (i = 0; i < n_sysdep_segments; i++)
 991                   {
 992                     const char *name =
 993                       (char *) data
 994                       + W (domain->must_swap, sysdep_segments[i].offset);
 995                     nls_uint32 namelen =
 996                       W (domain->must_swap, sysdep_segments[i].length);
 997
 998                     if (!(namelen > 0 && name[namelen - 1] == '\0'))
 999                       {
1000                         freea (sysdep_segment_values);
1001                         goto invalid;
1002                       }
1003
1004                     sysdep_segment_values[i] = get_sysdep_segment_value (name);
1005                   }
1006
1007                 orig_sysdep_tab = (const nls_uint32 *)
1008                   ((char *) data
1009                    + W (domain->must_swap, data->orig_sysdep_tab_offset));
1010                 trans_sysdep_tab = (const nls_uint32 *)
1011                   ((char *) data
1012                    + W (domain->must_swap, data->trans_sysdep_tab_offset));
1013
1014                 /* Compute the amount of additional memory needed for the
1015                    system dependent strings and the augmented hash table.
1016                    At the same time, also drop string pairs which refer to
1017                    an undefined system dependent segment.  */
1018                 n_inmem_sysdep_strings = 0;
1019                 memneed = domain->hash_size * sizeof (nls_uint32);
1020                 for (i = 0; i < n_sysdep_strings; i++)
1021                   {
1022                     int valid = 1;
1023                     size_t needs[2];
1024
1025                     for (j = 0; j < 2; j++)
1026                       {
1027                         const struct sysdep_string *sysdep_string =
1028                           (const struct sysdep_string *)
1029                           ((char *) data
1030                            + W (domain->must_swap,
1031                                 j == 0
1032                                 ? orig_sysdep_tab[i]
1033                                 : trans_sysdep_tab[i]));
1034                         size_t need = 0;
1035                         const struct segment_pair *p = sysdep_string->segments;
1036
1037                         if (W (domain->must_swap, p->sysdepref) != SEGMENTS_END)
1038                           for (p = sysdep_string->segments;; p++)
1039                             {
1040                               nls_uint32 sysdepref;
1041
1042                               need += W (domain->must_swap, p->segsize);
1043
1044                               sysdepref = W (domain->must_swap, p->sysdepref);
1045                               if (sysdepref == SEGMENTS_END)
1046                                 break;
1047
1048                               if (sysdepref >= n_sysdep_segments)
1049                                 {
1050                                   /* Invalid.  */
1051                                   freea (sysdep_segment_values);
1052                                   goto invalid;
1053                                 }
1054
1055                               if (sysdep_segment_values[sysdepref] == NULL)
1056                                 {
1057                                   /* This particular string pair is invalid.  */
1058                                   valid = 0;
1059                                   break;
1060                                 }
1061
1062                               need += strlen (sysdep_segment_values[sysdepref]);
1063                             }
1064
1065                         needs[j] = need;
1066                         if (!valid)
1067                           break;
1068                       }
1069
1070                     if (valid)
1071                       {
1072                         n_inmem_sysdep_strings++;
1073                         memneed += needs[0] + needs[1];
1074                       }
1075                   }
1076                 memneed += 2 * n_inmem_sysdep_strings
1077                            * sizeof (struct sysdep_string_desc);
1078
1079                 if (n_inmem_sysdep_strings > 0)
1080                   {
1081                     unsigned int k;
1082
1083                     /* Allocate additional memory.  */
1084                     mem = (char *) malloc (memneed);
1085                     if (mem == NULL)
1086                       goto invalid;
1087
1088                     domain->malloced = mem;
1089                     inmem_orig_sysdep_tab = (struct sysdep_string_desc *) mem;
1090                     mem += n_inmem_sysdep_strings
1091                            * sizeof (struct sysdep_string_desc);
1092                     inmem_trans_sysdep_tab = (struct sysdep_string_desc *) mem;
1093                     mem += n_inmem_sysdep_strings
1094                            * sizeof (struct sysdep_string_desc);
1095                     inmem_hash_tab = (nls_uint32 *) mem;
1096                     mem += domain->hash_size * sizeof (nls_uint32);
1097
1098                     /* Compute the system dependent strings.  */
1099                     k = 0;
1100                     for (i = 0; i < n_sysdep_strings; i++)
1101                       {
1102                         int valid = 1;
1103
1104                         for (j = 0; j < 2; j++)
1105                           {
1106                             const struct sysdep_string *sysdep_string =
1107                               (const struct sysdep_string *)
1108                               ((char *) data
1109                                + W (domain->must_swap,
1110                                     j == 0
1111                                     ? orig_sysdep_tab[i]
1112                                     : trans_sysdep_tab[i]));
1113                             const struct segment_pair *p =
1114                               sysdep_string->segments;
1115
1116                             if (W (domain->must_swap, p->sysdepref)
1117                                 != SEGMENTS_END)
1118                               for (p = sysdep_string->segments;; p++)
1119                                 {
1120                                   nls_uint32 sysdepref;
1121
1122                                   sysdepref =
1123                                     W (domain->must_swap, p->sysdepref);
1124                                   if (sysdepref == SEGMENTS_END)
1125                                     break;
1126
1127                                   if (sysdep_segment_values[sysdepref] == NULL)
1128                                     {
1129                                       /* This particular string pair is
1130                                          invalid.  */
1131                                       valid = 0;
1132                                       break;
1133                                     }
1134                                 }
1135
1136                             if (!valid)
1137                               break;
1138                           }
1139
1140                         if (valid)
1141                           {
1142                             for (j = 0; j < 2; j++)
1143                               {
1144                                 const struct sysdep_string *sysdep_string =
1145                                   (const struct sysdep_string *)
1146                                   ((char *) data
1147                                    + W (domain->must_swap,
1148                                         j == 0
1149                                         ? orig_sysdep_tab[i]
1150                                         : trans_sysdep_tab[i]));
1151                                 const char *static_segments =
1152                                   (char *) data
1153                                   + W (domain->must_swap, sysdep_string->offset);
1154                                 const struct segment_pair *p =
1155                                   sysdep_string->segments;
1156
1157                                 /* Concatenate the segments, and fill
1158                                    inmem_orig_sysdep_tab[k] (for j == 0) and
1159                                    inmem_trans_sysdep_tab[k] (for j == 1).  */
1160
1161                                 struct sysdep_string_desc *inmem_tab_entry =
1162                                   (j == 0
1163                                    ? inmem_orig_sysdep_tab
1164                                    : inmem_trans_sysdep_tab)
1165                                   + k;
1166
1167                                 if (W (domain->must_swap, p->sysdepref)
1168                                     == SEGMENTS_END)
1169                                   {
1170                                     /* Only one static segment.  */
1171                                     inmem_tab_entry->length =
1172                                       W (domain->must_swap, p->segsize);
1173                                     inmem_tab_entry->pointer = static_segments;
1174                                   }
1175                                 else
1176                                   {
1177                                     inmem_tab_entry->pointer = mem;
1178
1179                                     for (p = sysdep_string->segments;; p++)
1180                                       {
1181                                         nls_uint32 segsize =
1182                                           W (domain->must_swap, p->segsize);
1183                                         nls_uint32 sysdepref =
1184                                           W (domain->must_swap, p->sysdepref);
1185                                         size_t n;
1186
1187                                         if (segsize > 0)
1188                                           {
1189                                             memcpy (mem, static_segments, segsize);
1190                                             mem += segsize;
1191                                             static_segments += segsize;
1192                                           }
1193
1194                                         if (sysdepref == SEGMENTS_END)
1195                                           break;
1196
1197                                         n = strlen (sysdep_segment_values[sysdepref]);
1198                                         memcpy (mem, sysdep_segment_values[sysdepref], n);
1199                                         mem += n;
1200                                       }
1201
1202                                     inmem_tab_entry->length =
1203                                       mem - inmem_tab_entry->pointer;
1204                                   }
1205                               }
1206
1207                             k++;
1208                           }
1209                       }
1210                     if (k != n_inmem_sysdep_strings)
1211                       abort ();
1212
1213                     /* Compute the augmented hash table.  */
1214                     for (i = 0; i < domain->hash_size; i++)
1215                       inmem_hash_tab[i] =
1216                         W (domain->must_swap_hash_tab, domain->hash_tab[i]);
1217                     for (i = 0; i < n_inmem_sysdep_strings; i++)
1218                       {
1219                         const char *msgid = inmem_orig_sysdep_tab[i].pointer;
1220                         nls_uint32 hash_val = __hash_string (msgid);
1221                         nls_uint32 idx = hash_val % domain->hash_size;
1222                         nls_uint32 incr =
1223                           1 + (hash_val % (domain->hash_size - 2));
1224
1225                         for (;;)
1226                           {
1227                             if (inmem_hash_tab[idx] == 0)
1228                               {
1229                                 /* Hash table entry is empty.  Use it.  */
1230                                 inmem_hash_tab[idx] = 1 + domain->nstrings + i;
1231                                 break;
1232                               }
1233
1234                             if (idx >= domain->hash_size - incr)
1235                               idx -= domain->hash_size - incr;
1236                             else
1237                               idx += incr;
1238                           }
1239                       }
1240
1241                     domain->n_sysdep_strings = n_inmem_sysdep_strings;
1242                     domain->orig_sysdep_tab = inmem_orig_sysdep_tab;
1243                     domain->trans_sysdep_tab = inmem_trans_sysdep_tab;
1244
1245                     domain->hash_tab = inmem_hash_tab;
1246                     domain->must_swap_hash_tab = 0;
1247                   }
1248                 else
1249                   {
1250                     domain->n_sysdep_strings = 0;
1251                     domain->orig_sysdep_tab = NULL;
1252                     domain->trans_sysdep_tab = NULL;
1253                   }
1254
1255                 freea (sysdep_segment_values);
1256               }
1257             else
1258               {
1259                 domain->n_sysdep_strings = 0;
1260                 domain->orig_sysdep_tab = NULL;
1261                 domain->trans_sysdep_tab = NULL;
1262               }
1263           }
1264           break;
1265         }
1266       break;
1267     default:
1268       /* This is an invalid revision.  */
1269     invalid:
1270       /* This is an invalid .mo file or we ran out of resources.  */
1271       free (domain->malloced);
1272 #ifdef HAVE_MMAP
1273       if (use_mmap)
1274         munmap ((caddr_t) data, size);
1275       else
1276 #endif
1277         free (data);
1278       free (domain);
1279       domain_file->data = NULL;
1280       goto out;
1281     }
1282
1283   /* No caches of converted translations so far.  */
1284   domain->conversions = NULL;
1285   domain->nconversions = 0;
1286 #ifdef _LIBC
1287   __libc_rwlock_init (domain->conversions_lock);
1288 #else
1289   gl_rwlock_init (domain->conversions_lock);
1290 #endif
1291
1292   /* Get the header entry and look for a plural specification.  */
1293 #ifdef IN_LIBGLOCALE
1294   nullentry =
1295     _nl_find_msg (domain_file, domainbinding, NULL, "", &nullentrylen);
1296 #else
1297   nullentry = _nl_find_msg (domain_file, domainbinding, "", 0, &nullentrylen);
1298 #endif
1299   if (__builtin_expect (nullentry == (char *) -1, 0))
1300     {
1301 #ifdef _LIBC
1302       __libc_rwlock_fini (domain->conversions_lock);
1303 #endif
1304       goto invalid;
1305     }
1306   EXTRACT_PLURAL_EXPRESSION (nullentry, &domain->plural, &domain->nplurals);
1307
1308  out:
1309   if (fd != -1)
1310     close (fd);
1311
1312   domain_file->decided = 1;
1313
1314  done:
1315   __libc_lock_unlock_recursive (lock);
1316 }
1317
1318
1319 #ifdef _LIBC
1320 void
1321 internal_function __libc_freeres_fn_section
1322 _nl_unload_domain (struct loaded_domain *domain)
1323 {
1324   size_t i;
1325
1326   if (domain->plural != &__gettext_germanic_plural)
1327     __gettext_free_exp ((struct expression *) domain->plural);
1328
1329   for (i = 0; i < domain->nconversions; i++)
1330     {
1331       struct converted_domain *convd = &domain->conversions[i];
1332
1333       free ((char *) convd->encoding);
1334       if (convd->conv_tab != NULL && convd->conv_tab != (char **) -1)
1335         free (convd->conv_tab);
1336       if (convd->conv != (__gconv_t) -1)
1337         __gconv_close (convd->conv);
1338     }
1339   free (domain->conversions);
1340   __libc_rwlock_fini (domain->conversions_lock);
1341
1342   free (domain->malloced);
1343
1344 # ifdef _POSIX_MAPPED_FILES
1345   if (domain->use_mmap)
1346     munmap ((caddr_t) domain->data, domain->mmap_size);
1347   else
1348 # endif /* _POSIX_MAPPED_FILES */
1349     free ((void *) domain->data);
1350
1351   free (domain);
1352 }
1353 #endif