intl/loadmsgcat.c

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