intl/loadmsgcat.c

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