gettext-runtime/intl/loadmsgcat.c

   1 /* Load needed message catalogs.
   2    Copyright (C) 1995-1999, 2000-2008, 2010 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU Lesser General Public License as published by
   6    the Free Software Foundation; either version 2.1 of the License, or
   7    (at your option) 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
  12    GNU Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  16
  17 /* Tell glibc's <string.h> to provide a prototype for mempcpy().
  18    This must come before <config.h> because <config.h> may include
  19    <features.h>, and once <features.h> has been included, it's too late.  */
  20 #ifndef _GNU_SOURCE
  21 # define _GNU_SOURCE    1
  22 #endif
  23
  24 #ifdef HAVE_CONFIG_H
  25 # include <config.h>
  26 #endif
  27
  28 #include <ctype.h>
  29 #include <errno.h>
  30 #include <fcntl.h>
  31 #include <sys/types.h>
  32 #include <sys/stat.h>
  33
  34 #ifdef __GNUC__
  35 # undef  alloca
  36 # define alloca __builtin_alloca
  37 # define HAVE_ALLOCA 1
  38 #else
  39 # ifdef _MSC_VER
  40 #  include <malloc.h>
  41 #  define alloca _alloca
  42 # else
  43 #  if defined HAVE_ALLOCA_H || defined _LIBC
  44 #   include <alloca.h>
  45 #  else
  46 #   ifdef _AIX
  47  #pragma alloca
  48 #   else
  49 #    ifndef alloca
  50 char *alloca ();
  51 #    endif
  52 #   endif
  53 #  endif
  54 # endif
  55 #endif
  56
  57 #include <stdlib.h>
  58 #include <string.h>
  59
  60 #if defined HAVE_UNISTD_H || defined _LIBC
  61 # include <unistd.h>
  62 #endif
  63
  64 #ifdef _LIBC
  65 # include <langinfo.h>
  66 # include <locale.h>
  67 #endif
  68
  69 #if (defined HAVE_MMAP && defined HAVE_MUNMAP && !defined DISALLOW_MMAP) \
  70     || (defined _LIBC && defined _POSIX_MAPPED_FILES)
  71 # include <sys/mman.h>
  72 # undef HAVE_MMAP
  73 # define HAVE_MMAP      1
  74 #else
  75 # undef HAVE_MMAP
  76 #endif
  77
  78 #if defined HAVE_STDINT_H_WITH_UINTMAX || defined _LIBC
  79 # include <stdint.h>
  80 #endif
  81 #if defined HAVE_INTTYPES_H || defined _LIBC
  82 # include <inttypes.h>
  83 #endif
  84
  85 #include "gmo.h"
  86 #include "gettextP.h"
  87 #include "hash-string.h"
  88 #include "plural-exp.h"
  89
  90 #ifdef _LIBC
  91 # include "../locale/localeinfo.h"
  92 # include <not-cancel.h>
  93 #endif
  94
  95 /* Handle multi-threaded applications.  */
  96 #ifdef _LIBC
  97 # include <bits/libc-lock.h>
  98 #else
  99 # include "lock.h"
 100 #endif
 101
 102 /* Provide fallback values for macros that ought to be defined in <inttypes.h>.
 103    Note that our fallback values need not be literal strings, because we don't
 104    use them with preprocessor string concatenation.  */
 105 #if !defined PRId8 || PRI_MACROS_BROKEN
 106 # undef PRId8
 107 # define PRId8 "d"
 108 #endif
 109 #if !defined PRIi8 || PRI_MACROS_BROKEN
 110 # undef PRIi8
 111 # define PRIi8 "i"
 112 #endif
 113 #if !defined PRIo8 || PRI_MACROS_BROKEN
 114 # undef PRIo8
 115 # define PRIo8 "o"
 116 #endif
 117 #if !defined PRIu8 || PRI_MACROS_BROKEN
 118 # undef PRIu8
 119 # define PRIu8 "u"
 120 #endif
 121 #if !defined PRIx8 || PRI_MACROS_BROKEN
 122 # undef PRIx8
 123 # define PRIx8 "x"
 124 #endif
 125 #if !defined PRIX8 || PRI_MACROS_BROKEN
 126 # undef PRIX8
 127 # define PRIX8 "X"
 128 #endif
 129 #if !defined PRId16 || PRI_MACROS_BROKEN
 130 # undef PRId16
 131 # define PRId16 "d"
 132 #endif
 133 #if !defined PRIi16 || PRI_MACROS_BROKEN
 134 # undef PRIi16
 135 # define PRIi16 "i"
 136 #endif
 137 #if !defined PRIo16 || PRI_MACROS_BROKEN
 138 # undef PRIo16
 139 # define PRIo16 "o"
 140 #endif
 141 #if !defined PRIu16 || PRI_MACROS_BROKEN
 142 # undef PRIu16
 143 # define PRIu16 "u"
 144 #endif
 145 #if !defined PRIx16 || PRI_MACROS_BROKEN
 146 # undef PRIx16
 147 # define PRIx16 "x"
 148 #endif
 149 #if !defined PRIX16 || PRI_MACROS_BROKEN
 150 # undef PRIX16
 151 # define PRIX16 "X"
 152 #endif
 153 #if !defined PRId32 || PRI_MACROS_BROKEN
 154 # undef PRId32
 155 # define PRId32 "d"
 156 #endif
 157 #if !defined PRIi32 || PRI_MACROS_BROKEN
 158 # undef PRIi32
 159 # define PRIi32 "i"
 160 #endif
 161 #if !defined PRIo32 || PRI_MACROS_BROKEN
 162 # undef PRIo32
 163 # define PRIo32 "o"
 164 #endif
 165 #if !defined PRIu32 || PRI_MACROS_BROKEN
 166 # undef PRIu32
 167 # define PRIu32 "u"
 168 #endif
 169 #if !defined PRIx32 || PRI_MACROS_BROKEN
 170 # undef PRIx32
 171 # define PRIx32 "x"
 172 #endif
 173 #if !defined PRIX32 || PRI_MACROS_BROKEN
 174 # undef PRIX32
 175 # define PRIX32 "X"
 176 #endif
 177 #if !defined PRId64 || PRI_MACROS_BROKEN
 178 # undef PRId64
 179 # define PRId64 (sizeof (long) == 8 ? "ld" : "lld")
 180 #endif
 181 #if !defined PRIi64 || PRI_MACROS_BROKEN
 182 # undef PRIi64
 183 # define PRIi64 (sizeof (long) == 8 ? "li" : "lli")
 184 #endif
 185 #if !defined PRIo64 || PRI_MACROS_BROKEN
 186 # undef PRIo64
 187 # define PRIo64 (sizeof (long) == 8 ? "lo" : "llo")
 188 #endif
 189 #if !defined PRIu64 || PRI_MACROS_BROKEN
 190 # undef PRIu64
 191 # define PRIu64 (sizeof (long) == 8 ? "lu" : "llu")
 192 #endif
 193 #if !defined PRIx64 || PRI_MACROS_BROKEN
 194 # undef PRIx64
 195 # define PRIx64 (sizeof (long) == 8 ? "lx" : "llx")
 196 #endif
 197 #if !defined PRIX64 || PRI_MACROS_BROKEN
 198 # undef PRIX64
 199 # define PRIX64 (sizeof (long) == 8 ? "lX" : "llX")
 200 #endif
 201 #if !defined PRIdLEAST8 || PRI_MACROS_BROKEN
 202 # undef PRIdLEAST8
 203 # define PRIdLEAST8 "d"
 204 #endif
 205 #if !defined PRIiLEAST8 || PRI_MACROS_BROKEN
 206 # undef PRIiLEAST8
 207 # define PRIiLEAST8 "i"
 208 #endif
 209 #if !defined PRIoLEAST8 || PRI_MACROS_BROKEN
 210 # undef PRIoLEAST8
 211 # define PRIoLEAST8 "o"
 212 #endif
 213 #if !defined PRIuLEAST8 || PRI_MACROS_BROKEN
 214 # undef PRIuLEAST8
 215 # define PRIuLEAST8 "u"
 216 #endif
 217 #if !defined PRIxLEAST8 || PRI_MACROS_BROKEN
 218 # undef PRIxLEAST8
 219 # define PRIxLEAST8 "x"
 220 #endif
 221 #if !defined PRIXLEAST8 || PRI_MACROS_BROKEN
 222 # undef PRIXLEAST8
 223 # define PRIXLEAST8 "X"
 224 #endif
 225 #if !defined PRIdLEAST16 || PRI_MACROS_BROKEN
 226 # undef PRIdLEAST16
 227 # define PRIdLEAST16 "d"
 228 #endif
 229 #if !defined PRIiLEAST16 || PRI_MACROS_BROKEN
 230 # undef PRIiLEAST16
 231 # define PRIiLEAST16 "i"
 232 #endif
 233 #if !defined PRIoLEAST16 || PRI_MACROS_BROKEN
 234 # undef PRIoLEAST16
 235 # define PRIoLEAST16 "o"
 236 #endif
 237 #if !defined PRIuLEAST16 || PRI_MACROS_BROKEN
 238 # undef PRIuLEAST16
 239 # define PRIuLEAST16 "u"
 240 #endif
 241 #if !defined PRIxLEAST16 || PRI_MACROS_BROKEN
 242 # undef PRIxLEAST16
 243 # define PRIxLEAST16 "x"
 244 #endif
 245 #if !defined PRIXLEAST16 || PRI_MACROS_BROKEN
 246 # undef PRIXLEAST16
 247 # define PRIXLEAST16 "X"
 248 #endif
 249 #if !defined PRIdLEAST32 || PRI_MACROS_BROKEN
 250 # undef PRIdLEAST32
 251 # define PRIdLEAST32 "d"
 252 #endif
 253 #if !defined PRIiLEAST32 || PRI_MACROS_BROKEN
 254 # undef PRIiLEAST32
 255 # define PRIiLEAST32 "i"
 256 #endif
 257 #if !defined PRIoLEAST32 || PRI_MACROS_BROKEN
 258 # undef PRIoLEAST32
 259 # define PRIoLEAST32 "o"
 260 #endif
 261 #if !defined PRIuLEAST32 || PRI_MACROS_BROKEN
 262 # undef PRIuLEAST32
 263 # define PRIuLEAST32 "u"
 264 #endif
 265 #if !defined PRIxLEAST32 || PRI_MACROS_BROKEN
 266 # undef PRIxLEAST32
 267 # define PRIxLEAST32 "x"
 268 #endif
 269 #if !defined PRIXLEAST32 || PRI_MACROS_BROKEN
 270 # undef PRIXLEAST32
 271 # define PRIXLEAST32 "X"
 272 #endif
 273 #if !defined PRIdLEAST64 || PRI_MACROS_BROKEN
 274 # undef PRIdLEAST64
 275 # define PRIdLEAST64 PRId64
 276 #endif
 277 #if !defined PRIiLEAST64 || PRI_MACROS_BROKEN
 278 # undef PRIiLEAST64
 279 # define PRIiLEAST64 PRIi64
 280 #endif
 281 #if !defined PRIoLEAST64 || PRI_MACROS_BROKEN
 282 # undef PRIoLEAST64
 283 # define PRIoLEAST64 PRIo64
 284 #endif
 285 #if !defined PRIuLEAST64 || PRI_MACROS_BROKEN
 286 # undef PRIuLEAST64
 287 # define PRIuLEAST64 PRIu64
 288 #endif
 289 #if !defined PRIxLEAST64 || PRI_MACROS_BROKEN
 290 # undef PRIxLEAST64
 291 # define PRIxLEAST64 PRIx64
 292 #endif
 293 #if !defined PRIXLEAST64 || PRI_MACROS_BROKEN
 294 # undef PRIXLEAST64
 295 # define PRIXLEAST64 PRIX64
 296 #endif
 297 #if !defined PRIdFAST8 || PRI_MACROS_BROKEN
 298 # undef PRIdFAST8
 299 # define PRIdFAST8 "d"
 300 #endif
 301 #if !defined PRIiFAST8 || PRI_MACROS_BROKEN
 302 # undef PRIiFAST8
 303 # define PRIiFAST8 "i"
 304 #endif
 305 #if !defined PRIoFAST8 || PRI_MACROS_BROKEN
 306 # undef PRIoFAST8
 307 # define PRIoFAST8 "o"
 308 #endif
 309 #if !defined PRIuFAST8 || PRI_MACROS_BROKEN
 310 # undef PRIuFAST8
 311 # define PRIuFAST8 "u"
 312 #endif
 313 #if !defined PRIxFAST8 || PRI_MACROS_BROKEN
 314 # undef PRIxFAST8
 315 # define PRIxFAST8 "x"
 316 #endif
 317 #if !defined PRIXFAST8 || PRI_MACROS_BROKEN
 318 # undef PRIXFAST8
 319 # define PRIXFAST8 "X"
 320 #endif
 321 #if !defined PRIdFAST16 || PRI_MACROS_BROKEN
 322 # undef PRIdFAST16
 323 # define PRIdFAST16 "d"
 324 #endif
 325 #if !defined PRIiFAST16 || PRI_MACROS_BROKEN
 326 # undef PRIiFAST16
 327 # define PRIiFAST16 "i"
 328 #endif
 329 #if !defined PRIoFAST16 || PRI_MACROS_BROKEN
 330 # undef PRIoFAST16
 331 # define PRIoFAST16 "o"
 332 #endif
 333 #if !defined PRIuFAST16 || PRI_MACROS_BROKEN
 334 # undef PRIuFAST16
 335 # define PRIuFAST16 "u"
 336 #endif
 337 #if !defined PRIxFAST16 || PRI_MACROS_BROKEN
 338 # undef PRIxFAST16
 339 # define PRIxFAST16 "x"
 340 #endif
 341 #if !defined PRIXFAST16 || PRI_MACROS_BROKEN
 342 # undef PRIXFAST16
 343 # define PRIXFAST16 "X"
 344 #endif
 345 #if !defined PRIdFAST32 || PRI_MACROS_BROKEN
 346 # undef PRIdFAST32
 347 # define PRIdFAST32 "d"
 348 #endif
 349 #if !defined PRIiFAST32 || PRI_MACROS_BROKEN
 350 # undef PRIiFAST32
 351 # define PRIiFAST32 "i"
 352 #endif
 353 #if !defined PRIoFAST32 || PRI_MACROS_BROKEN
 354 # undef PRIoFAST32
 355 # define PRIoFAST32 "o"
 356 #endif
 357 #if !defined PRIuFAST32 || PRI_MACROS_BROKEN
 358 # undef PRIuFAST32
 359 # define PRIuFAST32 "u"
 360 #endif
 361 #if !defined PRIxFAST32 || PRI_MACROS_BROKEN
 362 # undef PRIxFAST32
 363 # define PRIxFAST32 "x"
 364 #endif
 365 #if !defined PRIXFAST32 || PRI_MACROS_BROKEN
 366 # undef PRIXFAST32
 367 # define PRIXFAST32 "X"
 368 #endif
 369 #if !defined PRIdFAST64 || PRI_MACROS_BROKEN
 370 # undef PRIdFAST64
 371 # define PRIdFAST64 PRId64
 372 #endif
 373 #if !defined PRIiFAST64 || PRI_MACROS_BROKEN
 374 # undef PRIiFAST64
 375 # define PRIiFAST64 PRIi64
 376 #endif
 377 #if !defined PRIoFAST64 || PRI_MACROS_BROKEN
 378 # undef PRIoFAST64
 379 # define PRIoFAST64 PRIo64
 380 #endif
 381 #if !defined PRIuFAST64 || PRI_MACROS_BROKEN
 382 # undef PRIuFAST64
 383 # define PRIuFAST64 PRIu64
 384 #endif
 385 #if !defined PRIxFAST64 || PRI_MACROS_BROKEN
 386 # undef PRIxFAST64
 387 # define PRIxFAST64 PRIx64
 388 #endif
 389 #if !defined PRIXFAST64 || PRI_MACROS_BROKEN
 390 # undef PRIXFAST64
 391 # define PRIXFAST64 PRIX64
 392 #endif
 393 #if !defined PRIdMAX || PRI_MACROS_BROKEN
 394 # undef PRIdMAX
 395 # define PRIdMAX (sizeof (uintmax_t) == sizeof (long) ? "ld" : "lld")
 396 #endif
 397 #if !defined PRIiMAX || PRI_MACROS_BROKEN
 398 # undef PRIiMAX
 399 # define PRIiMAX (sizeof (uintmax_t) == sizeof (long) ? "li" : "lli")
 400 #endif
 401 #if !defined PRIoMAX || PRI_MACROS_BROKEN
 402 # undef PRIoMAX
 403 # define PRIoMAX (sizeof (uintmax_t) == sizeof (long) ? "lo" : "llo")
 404 #endif
 405 #if !defined PRIuMAX || PRI_MACROS_BROKEN
 406 # undef PRIuMAX
 407 # define PRIuMAX (sizeof (uintmax_t) == sizeof (long) ? "lu" : "llu")
 408 #endif
 409 #if !defined PRIxMAX || PRI_MACROS_BROKEN
 410 # undef PRIxMAX
 411 # define PRIxMAX (sizeof (uintmax_t) == sizeof (long) ? "lx" : "llx")
 412 #endif
 413 #if !defined PRIXMAX || PRI_MACROS_BROKEN
 414 # undef PRIXMAX
 415 # define PRIXMAX (sizeof (uintmax_t) == sizeof (long) ? "lX" : "llX")
 416 #endif
 417 #if !defined PRIdPTR || PRI_MACROS_BROKEN
 418 # undef PRIdPTR
 419 # define PRIdPTR \
 420   (sizeof (void *) == sizeof (long) ? "ld" : \
 421    sizeof (void *) == sizeof (int) ? "d" : \
 422    "lld")
 423 #endif
 424 #if !defined PRIiPTR || PRI_MACROS_BROKEN
 425 # undef PRIiPTR
 426 # define PRIiPTR \
 427   (sizeof (void *) == sizeof (long) ? "li" : \
 428    sizeof (void *) == sizeof (int) ? "i" : \
 429    "lli")
 430 #endif
 431 #if !defined PRIoPTR || PRI_MACROS_BROKEN
 432 # undef PRIoPTR
 433 # define PRIoPTR \
 434   (sizeof (void *) == sizeof (long) ? "lo" : \
 435    sizeof (void *) == sizeof (int) ? "o" : \
 436    "llo")
 437 #endif
 438 #if !defined PRIuPTR || PRI_MACROS_BROKEN
 439 # undef PRIuPTR
 440 # define PRIuPTR \
 441   (sizeof (void *) == sizeof (long) ? "lu" : \
 442    sizeof (void *) == sizeof (int) ? "u" : \
 443    "llu")
 444 #endif
 445 #if !defined PRIxPTR || PRI_MACROS_BROKEN
 446 # undef PRIxPTR
 447 # define PRIxPTR \
 448   (sizeof (void *) == sizeof (long) ? "lx" : \
 449    sizeof (void *) == sizeof (int) ? "x" : \
 450    "llx")
 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
 460 /* @@ end of prolog @@ */
 461
 462 #ifdef _LIBC
 463 /* Rename the non ISO C functions.  This is required by the standard
 464    because some ISO C functions will require linking with this object
 465    file and the name space must not be polluted.  */
 466 # define open(name, flags)      open_not_cancel_2 (name, flags)
 467 # define close(fd)              close_not_cancel_no_status (fd)
 468 # define read(fd, buf, n)       read_not_cancel (fd, buf, n)
 469 # define mmap(addr, len, prot, flags, fd, offset) \
 470   __mmap (addr, len, prot, flags, fd, offset)
 471 # define munmap(addr, len)      __munmap (addr, len)
 472 #endif
 473
 474 /* For those losing systems which don't have `alloca' we have to add
 475    some additional code emulating it.  */
 476 #ifdef HAVE_ALLOCA
 477 # define freea(p) /* nothing */
 478 #else
 479 # define alloca(n) malloc (n)
 480 # define freea(p) free (p)
 481 #endif
 482
 483 /* For systems that distinguish between text and binary I/O.
 484    O_BINARY is usually declared in <fcntl.h>. */
 485 #if !defined O_BINARY && defined _O_BINARY
 486   /* For MSC-compatible compilers.  */
 487 # define O_BINARY _O_BINARY
 488 # define O_TEXT _O_TEXT
 489 #endif
 490 #ifdef __BEOS__
 491   /* BeOS 5 has O_BINARY and O_TEXT, but they have no effect.  */
 492 # undef O_BINARY
 493 # undef O_TEXT
 494 #endif
 495 /* On reasonable systems, binary I/O is the default.  */
 496 #ifndef O_BINARY
 497 # define O_BINARY 0
 498 #endif
 499
 500
 501 /* We need a sign, whether a new catalog was loaded, which can be associated
 502    with all translations.  This is important if the translations are
 503    cached by one of GCC's features.  */
 504 int _nl_msg_cat_cntr;
 505
 506
 507 /* Expand a system dependent string segment.  Return NULL if unsupported.  */
 508 static const char *
 509 get_sysdep_segment_value (const char *name)
 510 {
 511   /* Test for an ISO C 99 section 7.8.1 format string directive.
 512      Syntax:
 513      P R I { d | i | o | u | x | X }
 514      { { | LEAST | FAST } { 8 | 16 | 32 | 64 } | MAX | PTR }  */
 515   /* We don't use a table of 14 times 6 'const char *' strings here, because
 516      data relocations cost startup time.  */
 517   if (name[0] == 'P' && name[1] == 'R' && name[2] == 'I')
 518     {
 519       if (name[3] == 'd' || name[3] == 'i' || name[3] == 'o' || name[3] == 'u'
 520           || name[3] == 'x' || name[3] == 'X')
 521         {
 522           if (name[4] == '8' && name[5] == '\0')
 523             {
 524               if (name[3] == 'd')
 525                 return PRId8;
 526               if (name[3] == 'i')
 527                 return PRIi8;
 528               if (name[3] == 'o')
 529                 return PRIo8;
 530               if (name[3] == 'u')
 531                 return PRIu8;
 532               if (name[3] == 'x')
 533                 return PRIx8;
 534               if (name[3] == 'X')
 535                 return PRIX8;
 536               abort ();
 537             }
 538           if (name[4] == '1' && name[5] == '6' && name[6] == '\0')
 539             {
 540               if (name[3] == 'd')
 541                 return PRId16;
 542               if (name[3] == 'i')
 543                 return PRIi16;
 544               if (name[3] == 'o')
 545                 return PRIo16;
 546               if (name[3] == 'u')
 547                 return PRIu16;
 548               if (name[3] == 'x')
 549                 return PRIx16;
 550               if (name[3] == 'X')
 551                 return PRIX16;
 552               abort ();
 553             }
 554           if (name[4] == '3' && name[5] == '2' && name[6] == '\0')
 555             {
 556               if (name[3] == 'd')
 557                 return PRId32;
 558               if (name[3] == 'i')
 559                 return PRIi32;
 560               if (name[3] == 'o')
 561                 return PRIo32;
 562               if (name[3] == 'u')
 563                 return PRIu32;
 564               if (name[3] == 'x')
 565                 return PRIx32;
 566               if (name[3] == 'X')
 567                 return PRIX32;
 568               abort ();
 569             }
 570           if (name[4] == '6' && name[5] == '4' && name[6] == '\0')
 571             {
 572               if (name[3] == 'd')
 573                 return PRId64;
 574               if (name[3] == 'i')
 575                 return PRIi64;
 576               if (name[3] == 'o')
 577                 return PRIo64;
 578               if (name[3] == 'u')
 579                 return PRIu64;
 580               if (name[3] == 'x')
 581                 return PRIx64;
 582               if (name[3] == 'X')
 583                 return PRIX64;
 584               abort ();
 585             }
 586           if (name[4] == 'L' && name[5] == 'E' && name[6] == 'A'
 587               && name[7] == 'S' && name[8] == 'T')
 588             {
 589               if (name[9] == '8' && name[10] == '\0')
 590                 {
 591                   if (name[3] == 'd')
 592                     return PRIdLEAST8;
 593                   if (name[3] == 'i')
 594                     return PRIiLEAST8;
 595                   if (name[3] == 'o')
 596                     return PRIoLEAST8;
 597                   if (name[3] == 'u')
 598                     return PRIuLEAST8;
 599                   if (name[3] == 'x')
 600                     return PRIxLEAST8;
 601                   if (name[3] == 'X')
 602                     return PRIXLEAST8;
 603                   abort ();
 604                 }
 605               if (name[9] == '1' && name[10] == '6' && name[11] == '\0')
 606                 {
 607                   if (name[3] == 'd')
 608                     return PRIdLEAST16;
 609                   if (name[3] == 'i')
 610                     return PRIiLEAST16;
 611                   if (name[3] == 'o')
 612                     return PRIoLEAST16;
 613                   if (name[3] == 'u')
 614                     return PRIuLEAST16;
 615                   if (name[3] == 'x')
 616                     return PRIxLEAST16;
 617                   if (name[3] == 'X')
 618                     return PRIXLEAST16;
 619                   abort ();
 620                 }
 621               if (name[9] == '3' && name[10] == '2' && name[11] == '\0')
 622                 {
 623                   if (name[3] == 'd')
 624                     return PRIdLEAST32;
 625                   if (name[3] == 'i')
 626                     return PRIiLEAST32;
 627                   if (name[3] == 'o')
 628                     return PRIoLEAST32;
 629                   if (name[3] == 'u')
 630                     return PRIuLEAST32;
 631                   if (name[3] == 'x')
 632                     return PRIxLEAST32;
 633                   if (name[3] == 'X')
 634                     return PRIXLEAST32;
 635                   abort ();
 636                 }
 637               if (name[9] == '6' && name[10] == '4' && name[11] == '\0')
 638                 {
 639                   if (name[3] == 'd')
 640                     return PRIdLEAST64;
 641                   if (name[3] == 'i')
 642                     return PRIiLEAST64;
 643                   if (name[3] == 'o')
 644                     return PRIoLEAST64;
 645                   if (name[3] == 'u')
 646                     return PRIuLEAST64;
 647                   if (name[3] == 'x')
 648                     return PRIxLEAST64;
 649                   if (name[3] == 'X')
 650                     return PRIXLEAST64;
 651                   abort ();
 652                 }
 653             }
 654           if (name[4] == 'F' && name[5] == 'A' && name[6] == 'S'
 655               && name[7] == 'T')
 656             {
 657               if (name[8] == '8' && name[9] == '\0')
 658                 {
 659                   if (name[3] == 'd')
 660                     return PRIdFAST8;
 661                   if (name[3] == 'i')
 662                     return PRIiFAST8;
 663                   if (name[3] == 'o')
 664                     return PRIoFAST8;
 665                   if (name[3] == 'u')
 666                     return PRIuFAST8;
 667                   if (name[3] == 'x')
 668                     return PRIxFAST8;
 669                   if (name[3] == 'X')
 670                     return PRIXFAST8;
 671                   abort ();
 672                 }
 673               if (name[8] == '1' && name[9] == '6' && name[10] == '\0')
 674                 {
 675                   if (name[3] == 'd')
 676                     return PRIdFAST16;
 677                   if (name[3] == 'i')
 678                     return PRIiFAST16;
 679                   if (name[3] == 'o')
 680                     return PRIoFAST16;
 681                   if (name[3] == 'u')
 682                     return PRIuFAST16;
 683                   if (name[3] == 'x')
 684                     return PRIxFAST16;
 685                   if (name[3] == 'X')
 686                     return PRIXFAST16;
 687                   abort ();
 688                 }
 689               if (name[8] == '3' && name[9] == '2' && name[10] == '\0')
 690                 {
 691                   if (name[3] == 'd')
 692                     return PRIdFAST32;
 693                   if (name[3] == 'i')
 694                     return PRIiFAST32;
 695                   if (name[3] == 'o')
 696                     return PRIoFAST32;
 697                   if (name[3] == 'u')
 698                     return PRIuFAST32;
 699                   if (name[3] == 'x')
 700                     return PRIxFAST32;
 701                   if (name[3] == 'X')
 702                     return PRIXFAST32;
 703                   abort ();
 704                 }
 705               if (name[8] == '6' && name[9] == '4' && name[10] == '\0')
 706                 {
 707                   if (name[3] == 'd')
 708                     return PRIdFAST64;
 709                   if (name[3] == 'i')
 710                     return PRIiFAST64;
 711                   if (name[3] == 'o')
 712                     return PRIoFAST64;
 713                   if (name[3] == 'u')
 714                     return PRIuFAST64;
 715                   if (name[3] == 'x')
 716                     return PRIxFAST64;
 717                   if (name[3] == 'X')
 718                     return PRIXFAST64;
 719                   abort ();
 720                 }
 721             }
 722           if (name[4] == 'M' && name[5] == 'A' && name[6] == 'X'
 723               && name[7] == '\0')
 724             {
 725               if (name[3] == 'd')
 726                 return PRIdMAX;
 727               if (name[3] == 'i')
 728                 return PRIiMAX;
 729               if (name[3] == 'o')
 730                 return PRIoMAX;
 731               if (name[3] == 'u')
 732                 return PRIuMAX;
 733               if (name[3] == 'x')
 734                 return PRIxMAX;
 735               if (name[3] == 'X')
 736                 return PRIXMAX;
 737               abort ();
 738             }
 739           if (name[4] == 'P' && name[5] == 'T' && name[6] == 'R'
 740               && name[7] == '\0')
 741             {
 742               if (name[3] == 'd')
 743                 return PRIdPTR;
 744               if (name[3] == 'i')
 745                 return PRIiPTR;
 746               if (name[3] == 'o')
 747                 return PRIoPTR;
 748               if (name[3] == 'u')
 749                 return PRIuPTR;
 750               if (name[3] == 'x')
 751                 return PRIxPTR;
 752               if (name[3] == 'X')
 753                 return PRIXPTR;
 754               abort ();
 755             }
 756         }
 757     }
 758   /* Test for a glibc specific printf() format directive flag.  */
 759   if (name[0] == 'I' && name[1] == '\0')
 760     {
 761 #if defined _LIBC \
 762     || ((__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)) \
 763         && !defined __UCLIBC__)
 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), some Indic languages, 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                   (const char **)
 980                   alloca (n_sysdep_segments * sizeof (const char *));
 981                 for (i = 0; i < n_sysdep_segments; i++)
 982                   {
 983                     const char *name =
 984                       (char *) data
 985                       + W (domain->must_swap, sysdep_segments[i].offset);
 986                     nls_uint32 namelen =
 987                       W (domain->must_swap, sysdep_segments[i].length);
 988
 989                     if (!(namelen > 0 && name[namelen - 1] == '\0'))
 990                       {
 991                         freea (sysdep_segment_values);
 992                         goto invalid;
 993                       }
 994
 995                     sysdep_segment_values[i] = get_sysdep_segment_value (name);
 996                   }
 997
 998                 orig_sysdep_tab = (const nls_uint32 *)
 999                   ((char *) data
1000                    + W (domain->must_swap, data->orig_sysdep_tab_offset));
1001                 trans_sysdep_tab = (const nls_uint32 *)
1002                   ((char *) data
1003                    + W (domain->must_swap, data->trans_sysdep_tab_offset));
1004
1005                 /* Compute the amount of additional memory needed for the
1006                    system dependent strings and the augmented hash table.
1007                    At the same time, also drop string pairs which refer to
1008                    an undefined system dependent segment.  */
1009                 n_inmem_sysdep_strings = 0;
1010                 memneed = domain->hash_size * sizeof (nls_uint32);
1011                 for (i = 0; i < n_sysdep_strings; i++)
1012                   {
1013                     int valid = 1;
1014                     size_t needs[2];
1015
1016                     for (j = 0; j < 2; j++)
1017                       {
1018                         const struct sysdep_string *sysdep_string =
1019                           (const struct sysdep_string *)
1020                           ((char *) data
1021                            + W (domain->must_swap,
1022                                 j == 0
1023                                 ? orig_sysdep_tab[i]
1024                                 : trans_sysdep_tab[i]));
1025                         size_t need = 0;
1026                         const struct segment_pair *p = sysdep_string->segments;
1027
1028                         if (W (domain->must_swap, p->sysdepref) != SEGMENTS_END)
1029                           for (p = sysdep_string->segments;; p++)
1030                             {
1031                               nls_uint32 sysdepref;
1032
1033                               need += W (domain->must_swap, p->segsize);
1034
1035                               sysdepref = W (domain->must_swap, p->sysdepref);
1036                               if (sysdepref == SEGMENTS_END)
1037                                 break;
1038
1039                               if (sysdepref >= n_sysdep_segments)
1040                                 {
1041                                   /* Invalid.  */
1042                                   freea (sysdep_segment_values);
1043                                   goto invalid;
1044                                 }
1045
1046                               if (sysdep_segment_values[sysdepref] == NULL)
1047                                 {
1048                                   /* This particular string pair is invalid.  */
1049                                   valid = 0;
1050                                   break;
1051                                 }
1052
1053                               need += strlen (sysdep_segment_values[sysdepref]);
1054                             }
1055
1056                         needs[j] = need;
1057                         if (!valid)
1058                           break;
1059                       }
1060
1061                     if (valid)
1062                       {
1063                         n_inmem_sysdep_strings++;
1064                         memneed += needs[0] + needs[1];
1065                       }
1066                   }
1067                 memneed += 2 * n_inmem_sysdep_strings
1068                            * sizeof (struct sysdep_string_desc);
1069
1070                 if (n_inmem_sysdep_strings > 0)
1071                   {
1072                     unsigned int k;
1073
1074                     /* Allocate additional memory.  */
1075                     mem = (char *) malloc (memneed);
1076                     if (mem == NULL)
1077                       goto invalid;
1078
1079                     domain->malloced = mem;
1080                     inmem_orig_sysdep_tab = (struct sysdep_string_desc *) mem;
1081                     mem += n_inmem_sysdep_strings
1082                            * sizeof (struct sysdep_string_desc);
1083                     inmem_trans_sysdep_tab = (struct sysdep_string_desc *) mem;
1084                     mem += n_inmem_sysdep_strings
1085                            * sizeof (struct sysdep_string_desc);
1086                     inmem_hash_tab = (nls_uint32 *) mem;
1087                     mem += domain->hash_size * sizeof (nls_uint32);
1088
1089                     /* Compute the system dependent strings.  */
1090                     k = 0;
1091                     for (i = 0; i < n_sysdep_strings; i++)
1092                       {
1093                         int valid = 1;
1094
1095                         for (j = 0; j < 2; j++)
1096                           {
1097                             const struct sysdep_string *sysdep_string =
1098                               (const struct sysdep_string *)
1099                               ((char *) data
1100                                + W (domain->must_swap,
1101                                     j == 0
1102                                     ? orig_sysdep_tab[i]
1103                                     : trans_sysdep_tab[i]));
1104                             const struct segment_pair *p =
1105                               sysdep_string->segments;
1106
1107                             if (W (domain->must_swap, p->sysdepref)
1108                                 != SEGMENTS_END)
1109                               for (p = sysdep_string->segments;; p++)
1110                                 {
1111                                   nls_uint32 sysdepref;
1112
1113                                   sysdepref =
1114                                     W (domain->must_swap, p->sysdepref);
1115                                   if (sysdepref == SEGMENTS_END)
1116                                     break;
1117
1118                                   if (sysdep_segment_values[sysdepref] == NULL)
1119                                     {
1120                                       /* This particular string pair is
1121                                          invalid.  */
1122                                       valid = 0;
1123                                       break;
1124                                     }
1125                                 }
1126
1127                             if (!valid)
1128                               break;
1129                           }
1130
1131                         if (valid)
1132                           {
1133                             for (j = 0; j < 2; j++)
1134                               {
1135                                 const struct sysdep_string *sysdep_string =
1136                                   (const struct sysdep_string *)
1137                                   ((char *) data
1138                                    + W (domain->must_swap,
1139                                         j == 0
1140                                         ? orig_sysdep_tab[i]
1141                                         : trans_sysdep_tab[i]));
1142                                 const char *static_segments =
1143                                   (char *) data
1144                                   + W (domain->must_swap, sysdep_string->offset);
1145                                 const struct segment_pair *p =
1146                                   sysdep_string->segments;
1147
1148                                 /* Concatenate the segments, and fill
1149                                    inmem_orig_sysdep_tab[k] (for j == 0) and
1150                                    inmem_trans_sysdep_tab[k] (for j == 1).  */
1151
1152                                 struct sysdep_string_desc *inmem_tab_entry =
1153                                   (j == 0
1154                                    ? inmem_orig_sysdep_tab
1155                                    : inmem_trans_sysdep_tab)
1156                                   + k;
1157
1158                                 if (W (domain->must_swap, p->sysdepref)
1159                                     == SEGMENTS_END)
1160                                   {
1161                                     /* Only one static segment.  */
1162                                     inmem_tab_entry->length =
1163                                       W (domain->must_swap, p->segsize);
1164                                     inmem_tab_entry->pointer = static_segments;
1165                                   }
1166                                 else
1167                                   {
1168                                     inmem_tab_entry->pointer = mem;
1169
1170                                     for (p = sysdep_string->segments;; p++)
1171                                       {
1172                                         nls_uint32 segsize =
1173                                           W (domain->must_swap, p->segsize);
1174                                         nls_uint32 sysdepref =
1175                                           W (domain->must_swap, p->sysdepref);
1176                                         size_t n;
1177
1178                                         if (segsize > 0)
1179                                           {
1180                                             memcpy (mem, static_segments, segsize);
1181                                             mem += segsize;
1182                                             static_segments += segsize;
1183                                           }
1184
1185                                         if (sysdepref == SEGMENTS_END)
1186                                           break;
1187
1188                                         n = strlen (sysdep_segment_values[sysdepref]);
1189                                         memcpy (mem, sysdep_segment_values[sysdepref], n);
1190                                         mem += n;
1191                                       }
1192
1193                                     inmem_tab_entry->length =
1194                                       mem - inmem_tab_entry->pointer;
1195                                   }
1196                               }
1197
1198                             k++;
1199                           }
1200                       }
1201                     if (k != n_inmem_sysdep_strings)
1202                       abort ();
1203
1204                     /* Compute the augmented hash table.  */
1205                     for (i = 0; i < domain->hash_size; i++)
1206                       inmem_hash_tab[i] =
1207                         W (domain->must_swap_hash_tab, domain->hash_tab[i]);
1208                     for (i = 0; i < n_inmem_sysdep_strings; i++)
1209                       {
1210                         const char *msgid = inmem_orig_sysdep_tab[i].pointer;
1211                         nls_uint32 hash_val = __hash_string (msgid);
1212                         nls_uint32 idx = hash_val % domain->hash_size;
1213                         nls_uint32 incr =
1214                           1 + (hash_val % (domain->hash_size - 2));
1215
1216                         for (;;)
1217                           {
1218                             if (inmem_hash_tab[idx] == 0)
1219                               {
1220                                 /* Hash table entry is empty.  Use it.  */
1221                                 inmem_hash_tab[idx] = 1 + domain->nstrings + i;
1222                                 break;
1223                               }
1224
1225                             if (idx >= domain->hash_size - incr)
1226                               idx -= domain->hash_size - incr;
1227                             else
1228                               idx += incr;
1229                           }
1230                       }
1231
1232                     domain->n_sysdep_strings = n_inmem_sysdep_strings;
1233                     domain->orig_sysdep_tab = inmem_orig_sysdep_tab;
1234                     domain->trans_sysdep_tab = inmem_trans_sysdep_tab;
1235
1236                     domain->hash_tab = inmem_hash_tab;
1237                     domain->must_swap_hash_tab = 0;
1238                   }
1239                 else
1240                   {
1241                     domain->n_sysdep_strings = 0;
1242                     domain->orig_sysdep_tab = NULL;
1243                     domain->trans_sysdep_tab = NULL;
1244                   }
1245
1246                 freea (sysdep_segment_values);
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           break;
1256         }
1257       break;
1258     default:
1259       /* This is an invalid revision.  */
1260     invalid:
1261       /* This is an invalid .mo file.  */
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   gl_rwlock_init (domain->conversions_lock);
1278
1279   /* Get the header entry and look for a plural specification.  */
1280 #ifdef IN_LIBGLOCALE
1281   nullentry =
1282     _nl_find_msg (domain_file, domainbinding, NULL, "", &nullentrylen);
1283 #else
1284   nullentry = _nl_find_msg (domain_file, domainbinding, "", 0, &nullentrylen);
1285 #endif
1286   EXTRACT_PLURAL_EXPRESSION (nullentry, &domain->plural, &domain->nplurals);
1287
1288  out:
1289   if (fd != -1)
1290     close (fd);
1291
1292   domain_file->decided = 1;
1293
1294  done:
1295   __libc_lock_unlock_recursive (lock);
1296 }
1297
1298
1299 #ifdef _LIBC
1300 void
1301 internal_function __libc_freeres_fn_section
1302 _nl_unload_domain (struct loaded_domain *domain)
1303 {
1304   size_t i;
1305
1306   if (domain->plural != &__gettext_germanic_plural)
1307     __gettext_free_exp ((struct expression *) domain->plural);
1308
1309   for (i = 0; i < domain->nconversions; i++)
1310     {
1311       struct converted_domain *convd = &domain->conversions[i];
1312
1313       free (convd->encoding);
1314       if (convd->conv_tab != NULL && convd->conv_tab != (char **) -1)
1315         free (convd->conv_tab);
1316       if (convd->conv != (__gconv_t) -1)
1317         __gconv_close (convd->conv);
1318     }
1319   free (domain->conversions);
1320   __libc_rwlock_fini (domain->conversions_lock);
1321
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