intl/loadmsgcat.c

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