intl/loadmsgcat.c

   1 /* Load needed message catalogs.
   2    Copyright (C) 1995-1999, 2000-2004 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 # undef  alloca
  38 # define alloca __builtin_alloca
  39 # define HAVE_ALLOCA 1
  40 #else
  41 # ifdef _MSC_VER
  42 #  include <malloc.h>
  43 #  define alloca _alloca
  44 # else
  45 #  if defined HAVE_ALLOCA_H || defined _LIBC
  46 #   include <alloca.h>
  47 #  else
  48 #   ifdef _AIX
  49  #pragma alloca
  50 #   else
  51 #    ifndef alloca
  52 char *alloca ();
  53 #    endif
  54 #   endif
  55 #  endif
  56 # endif
  57 #endif
  58
  59 #include <stdlib.h>
  60 #include <string.h>
  61
  62 #if defined HAVE_UNISTD_H || defined _LIBC
  63 # include <unistd.h>
  64 #endif
  65
  66 #ifdef _LIBC
  67 # include <langinfo.h>
  68 # include <locale.h>
  69 #endif
  70
  71 #if (defined HAVE_MMAP && defined HAVE_MUNMAP && !defined DISALLOW_MMAP) \
  72     || (defined _LIBC && defined _POSIX_MAPPED_FILES)
  73 # include <sys/mman.h>
  74 # undef HAVE_MMAP
  75 # define HAVE_MMAP      1
  76 #else
  77 # undef HAVE_MMAP
  78 #endif
  79
  80 #if defined HAVE_STDINT_H_WITH_UINTMAX || defined _LIBC
  81 # include <stdint.h>
  82 #endif
  83 #if defined HAVE_INTTYPES_H || defined _LIBC
  84 # include <inttypes.h>
  85 #endif
  86
  87 #include "gmo.h"
  88 #include "gettextP.h"
  89 #include "hash-string.h"
  90 #include "plural-exp.h"
  91
  92 #ifdef _LIBC
  93 # include "../locale/localeinfo.h"
  94 #endif
  95
  96 /* Provide fallback values for macros that ought to be defined in <inttypes.h>.
  97    Note that our fallback values need not be literal strings, because we don't
  98    use them with preprocessor string concatenation.  */
  99 #if !defined PRId8 || PRI_MACROS_BROKEN
 100 # undef PRId8
 101 # define PRId8 "d"
 102 #endif
 103 #if !defined PRIi8 || PRI_MACROS_BROKEN
 104 # undef PRIi8
 105 # define PRIi8 "i"
 106 #endif
 107 #if !defined PRIo8 || PRI_MACROS_BROKEN
 108 # undef PRIo8
 109 # define PRIo8 "o"
 110 #endif
 111 #if !defined PRIu8 || PRI_MACROS_BROKEN
 112 # undef PRIu8
 113 # define PRIu8 "u"
 114 #endif
 115 #if !defined PRIx8 || PRI_MACROS_BROKEN
 116 # undef PRIx8
 117 # define PRIx8 "x"
 118 #endif
 119 #if !defined PRIX8 || PRI_MACROS_BROKEN
 120 # undef PRIX8
 121 # define PRIX8 "X"
 122 #endif
 123 #if !defined PRId16 || PRI_MACROS_BROKEN
 124 # undef PRId16
 125 # define PRId16 "d"
 126 #endif
 127 #if !defined PRIi16 || PRI_MACROS_BROKEN
 128 # undef PRIi16
 129 # define PRIi16 "i"
 130 #endif
 131 #if !defined PRIo16 || PRI_MACROS_BROKEN
 132 # undef PRIo16
 133 # define PRIo16 "o"
 134 #endif
 135 #if !defined PRIu16 || PRI_MACROS_BROKEN
 136 # undef PRIu16
 137 # define PRIu16 "u"
 138 #endif
 139 #if !defined PRIx16 || PRI_MACROS_BROKEN
 140 # undef PRIx16
 141 # define PRIx16 "x"
 142 #endif
 143 #if !defined PRIX16 || PRI_MACROS_BROKEN
 144 # undef PRIX16
 145 # define PRIX16 "X"
 146 #endif
 147 #if !defined PRId32 || PRI_MACROS_BROKEN
 148 # undef PRId32
 149 # define PRId32 "d"
 150 #endif
 151 #if !defined PRIi32 || PRI_MACROS_BROKEN
 152 # undef PRIi32
 153 # define PRIi32 "i"
 154 #endif
 155 #if !defined PRIo32 || PRI_MACROS_BROKEN
 156 # undef PRIo32
 157 # define PRIo32 "o"
 158 #endif
 159 #if !defined PRIu32 || PRI_MACROS_BROKEN
 160 # undef PRIu32
 161 # define PRIu32 "u"
 162 #endif
 163 #if !defined PRIx32 || PRI_MACROS_BROKEN
 164 # undef PRIx32
 165 # define PRIx32 "x"
 166 #endif
 167 #if !defined PRIX32 || PRI_MACROS_BROKEN
 168 # undef PRIX32
 169 # define PRIX32 "X"
 170 #endif
 171 #if !defined PRId64 || PRI_MACROS_BROKEN
 172 # undef PRId64
 173 # define PRId64 (sizeof (long) == 8 ? "ld" : "lld")
 174 #endif
 175 #if !defined PRIi64 || PRI_MACROS_BROKEN
 176 # undef PRIi64
 177 # define PRIi64 (sizeof (long) == 8 ? "li" : "lli")
 178 #endif
 179 #if !defined PRIo64 || PRI_MACROS_BROKEN
 180 # undef PRIo64
 181 # define PRIo64 (sizeof (long) == 8 ? "lo" : "llo")
 182 #endif
 183 #if !defined PRIu64 || PRI_MACROS_BROKEN
 184 # undef PRIu64
 185 # define PRIu64 (sizeof (long) == 8 ? "lu" : "llu")
 186 #endif
 187 #if !defined PRIx64 || PRI_MACROS_BROKEN
 188 # undef PRIx64
 189 # define PRIx64 (sizeof (long) == 8 ? "lx" : "llx")
 190 #endif
 191 #if !defined PRIX64 || PRI_MACROS_BROKEN
 192 # undef PRIX64
 193 # define PRIX64 (sizeof (long) == 8 ? "lX" : "llX")
 194 #endif
 195 #if !defined PRIdLEAST8 || PRI_MACROS_BROKEN
 196 # undef PRIdLEAST8
 197 # define PRIdLEAST8 "d"
 198 #endif
 199 #if !defined PRIiLEAST8 || PRI_MACROS_BROKEN
 200 # undef PRIiLEAST8
 201 # define PRIiLEAST8 "i"
 202 #endif
 203 #if !defined PRIoLEAST8 || PRI_MACROS_BROKEN
 204 # undef PRIoLEAST8
 205 # define PRIoLEAST8 "o"
 206 #endif
 207 #if !defined PRIuLEAST8 || PRI_MACROS_BROKEN
 208 # undef PRIuLEAST8
 209 # define PRIuLEAST8 "u"
 210 #endif
 211 #if !defined PRIxLEAST8 || PRI_MACROS_BROKEN
 212 # undef PRIxLEAST8
 213 # define PRIxLEAST8 "x"
 214 #endif
 215 #if !defined PRIXLEAST8 || PRI_MACROS_BROKEN
 216 # undef PRIXLEAST8
 217 # define PRIXLEAST8 "X"
 218 #endif
 219 #if !defined PRIdLEAST16 || PRI_MACROS_BROKEN
 220 # undef PRIdLEAST16
 221 # define PRIdLEAST16 "d"
 222 #endif
 223 #if !defined PRIiLEAST16 || PRI_MACROS_BROKEN
 224 # undef PRIiLEAST16
 225 # define PRIiLEAST16 "i"
 226 #endif
 227 #if !defined PRIoLEAST16 || PRI_MACROS_BROKEN
 228 # undef PRIoLEAST16
 229 # define PRIoLEAST16 "o"
 230 #endif
 231 #if !defined PRIuLEAST16 || PRI_MACROS_BROKEN
 232 # undef PRIuLEAST16
 233 # define PRIuLEAST16 "u"
 234 #endif
 235 #if !defined PRIxLEAST16 || PRI_MACROS_BROKEN
 236 # undef PRIxLEAST16
 237 # define PRIxLEAST16 "x"
 238 #endif
 239 #if !defined PRIXLEAST16 || PRI_MACROS_BROKEN
 240 # undef PRIXLEAST16
 241 # define PRIXLEAST16 "X"
 242 #endif
 243 #if !defined PRIdLEAST32 || PRI_MACROS_BROKEN
 244 # undef PRIdLEAST32
 245 # define PRIdLEAST32 "d"
 246 #endif
 247 #if !defined PRIiLEAST32 || PRI_MACROS_BROKEN
 248 # undef PRIiLEAST32
 249 # define PRIiLEAST32 "i"
 250 #endif
 251 #if !defined PRIoLEAST32 || PRI_MACROS_BROKEN
 252 # undef PRIoLEAST32
 253 # define PRIoLEAST32 "o"
 254 #endif
 255 #if !defined PRIuLEAST32 || PRI_MACROS_BROKEN
 256 # undef PRIuLEAST32
 257 # define PRIuLEAST32 "u"
 258 #endif
 259 #if !defined PRIxLEAST32 || PRI_MACROS_BROKEN
 260 # undef PRIxLEAST32
 261 # define PRIxLEAST32 "x"
 262 #endif
 263 #if !defined PRIXLEAST32 || PRI_MACROS_BROKEN
 264 # undef PRIXLEAST32
 265 # define PRIXLEAST32 "X"
 266 #endif
 267 #if !defined PRIdLEAST64 || PRI_MACROS_BROKEN
 268 # undef PRIdLEAST64
 269 # define PRIdLEAST64 PRId64
 270 #endif
 271 #if !defined PRIiLEAST64 || PRI_MACROS_BROKEN
 272 # undef PRIiLEAST64
 273 # define PRIiLEAST64 PRIi64
 274 #endif
 275 #if !defined PRIoLEAST64 || PRI_MACROS_BROKEN
 276 # undef PRIoLEAST64
 277 # define PRIoLEAST64 PRIo64
 278 #endif
 279 #if !defined PRIuLEAST64 || PRI_MACROS_BROKEN
 280 # undef PRIuLEAST64
 281 # define PRIuLEAST64 PRIu64
 282 #endif
 283 #if !defined PRIxLEAST64 || PRI_MACROS_BROKEN
 284 # undef PRIxLEAST64
 285 # define PRIxLEAST64 PRIx64
 286 #endif
 287 #if !defined PRIXLEAST64 || PRI_MACROS_BROKEN
 288 # undef PRIXLEAST64
 289 # define PRIXLEAST64 PRIX64
 290 #endif
 291 #if !defined PRIdFAST8 || PRI_MACROS_BROKEN
 292 # undef PRIdFAST8
 293 # define PRIdFAST8 "d"
 294 #endif
 295 #if !defined PRIiFAST8 || PRI_MACROS_BROKEN
 296 # undef PRIiFAST8
 297 # define PRIiFAST8 "i"
 298 #endif
 299 #if !defined PRIoFAST8 || PRI_MACROS_BROKEN
 300 # undef PRIoFAST8
 301 # define PRIoFAST8 "o"
 302 #endif
 303 #if !defined PRIuFAST8 || PRI_MACROS_BROKEN
 304 # undef PRIuFAST8
 305 # define PRIuFAST8 "u"
 306 #endif
 307 #if !defined PRIxFAST8 || PRI_MACROS_BROKEN
 308 # undef PRIxFAST8
 309 # define PRIxFAST8 "x"
 310 #endif
 311 #if !defined PRIXFAST8 || PRI_MACROS_BROKEN
 312 # undef PRIXFAST8
 313 # define PRIXFAST8 "X"
 314 #endif
 315 #if !defined PRIdFAST16 || PRI_MACROS_BROKEN
 316 # undef PRIdFAST16
 317 # define PRIdFAST16 "d"
 318 #endif
 319 #if !defined PRIiFAST16 || PRI_MACROS_BROKEN
 320 # undef PRIiFAST16
 321 # define PRIiFAST16 "i"
 322 #endif
 323 #if !defined PRIoFAST16 || PRI_MACROS_BROKEN
 324 # undef PRIoFAST16
 325 # define PRIoFAST16 "o"
 326 #endif
 327 #if !defined PRIuFAST16 || PRI_MACROS_BROKEN
 328 # undef PRIuFAST16
 329 # define PRIuFAST16 "u"
 330 #endif
 331 #if !defined PRIxFAST16 || PRI_MACROS_BROKEN
 332 # undef PRIxFAST16
 333 # define PRIxFAST16 "x"
 334 #endif
 335 #if !defined PRIXFAST16 || PRI_MACROS_BROKEN
 336 # undef PRIXFAST16
 337 # define PRIXFAST16 "X"
 338 #endif
 339 #if !defined PRIdFAST32 || PRI_MACROS_BROKEN
 340 # undef PRIdFAST32
 341 # define PRIdFAST32 "d"
 342 #endif
 343 #if !defined PRIiFAST32 || PRI_MACROS_BROKEN
 344 # undef PRIiFAST32
 345 # define PRIiFAST32 "i"
 346 #endif
 347 #if !defined PRIoFAST32 || PRI_MACROS_BROKEN
 348 # undef PRIoFAST32
 349 # define PRIoFAST32 "o"
 350 #endif
 351 #if !defined PRIuFAST32 || PRI_MACROS_BROKEN
 352 # undef PRIuFAST32
 353 # define PRIuFAST32 "u"
 354 #endif
 355 #if !defined PRIxFAST32 || PRI_MACROS_BROKEN
 356 # undef PRIxFAST32
 357 # define PRIxFAST32 "x"
 358 #endif
 359 #if !defined PRIXFAST32 || PRI_MACROS_BROKEN
 360 # undef PRIXFAST32
 361 # define PRIXFAST32 "X"
 362 #endif
 363 #if !defined PRIdFAST64 || PRI_MACROS_BROKEN
 364 # undef PRIdFAST64
 365 # define PRIdFAST64 PRId64
 366 #endif
 367 #if !defined PRIiFAST64 || PRI_MACROS_BROKEN
 368 # undef PRIiFAST64
 369 # define PRIiFAST64 PRIi64
 370 #endif
 371 #if !defined PRIoFAST64 || PRI_MACROS_BROKEN
 372 # undef PRIoFAST64
 373 # define PRIoFAST64 PRIo64
 374 #endif
 375 #if !defined PRIuFAST64 || PRI_MACROS_BROKEN
 376 # undef PRIuFAST64
 377 # define PRIuFAST64 PRIu64
 378 #endif
 379 #if !defined PRIxFAST64 || PRI_MACROS_BROKEN
 380 # undef PRIxFAST64
 381 # define PRIxFAST64 PRIx64
 382 #endif
 383 #if !defined PRIXFAST64 || PRI_MACROS_BROKEN
 384 # undef PRIXFAST64
 385 # define PRIXFAST64 PRIX64
 386 #endif
 387 #if !defined PRIdMAX || PRI_MACROS_BROKEN
 388 # undef PRIdMAX
 389 # define PRIdMAX (sizeof (uintmax_t) == sizeof (long) ? "ld" : "lld")
 390 #endif
 391 #if !defined PRIiMAX || PRI_MACROS_BROKEN
 392 # undef PRIiMAX
 393 # define PRIiMAX (sizeof (uintmax_t) == sizeof (long) ? "li" : "lli")
 394 #endif
 395 #if !defined PRIoMAX || PRI_MACROS_BROKEN
 396 # undef PRIoMAX
 397 # define PRIoMAX (sizeof (uintmax_t) == sizeof (long) ? "lo" : "llo")
 398 #endif
 399 #if !defined PRIuMAX || PRI_MACROS_BROKEN
 400 # undef PRIuMAX
 401 # define PRIuMAX (sizeof (uintmax_t) == sizeof (long) ? "lu" : "llu")
 402 #endif
 403 #if !defined PRIxMAX || PRI_MACROS_BROKEN
 404 # undef PRIxMAX
 405 # define PRIxMAX (sizeof (uintmax_t) == sizeof (long) ? "lx" : "llx")
 406 #endif
 407 #if !defined PRIXMAX || PRI_MACROS_BROKEN
 408 # undef PRIXMAX
 409 # define PRIXMAX (sizeof (uintmax_t) == sizeof (long) ? "lX" : "llX")
 410 #endif
 411 #if !defined PRIdPTR || PRI_MACROS_BROKEN
 412 # undef PRIdPTR
 413 # define PRIdPTR \
 414   (sizeof (void *) == sizeof (long) ? "ld" : \
 415    sizeof (void *) == sizeof (int) ? "d" : \
 416    "lld")
 417 #endif
 418 #if !defined PRIiPTR || PRI_MACROS_BROKEN
 419 # undef PRIiPTR
 420 # define PRIiPTR \
 421   (sizeof (void *) == sizeof (long) ? "li" : \
 422    sizeof (void *) == sizeof (int) ? "i" : \
 423    "lli")
 424 #endif
 425 #if !defined PRIoPTR || PRI_MACROS_BROKEN
 426 # undef PRIoPTR
 427 # define PRIoPTR \
 428   (sizeof (void *) == sizeof (long) ? "lo" : \
 429    sizeof (void *) == sizeof (int) ? "o" : \
 430    "llo")
 431 #endif
 432 #if !defined PRIuPTR || PRI_MACROS_BROKEN
 433 # undef PRIuPTR
 434 # define PRIuPTR \
 435   (sizeof (void *) == sizeof (long) ? "lu" : \
 436    sizeof (void *) == sizeof (int) ? "u" : \
 437    "llu")
 438 #endif
 439 #if !defined PRIxPTR || PRI_MACROS_BROKEN
 440 # undef PRIxPTR
 441 # define PRIxPTR \
 442   (sizeof (void *) == sizeof (long) ? "lx" : \
 443    sizeof (void *) == sizeof (int) ? "x" : \
 444    "llx")
 445 #endif
 446 #if !defined PRIXPTR || PRI_MACROS_BROKEN
 447 # undef PRIXPTR
 448 # define PRIXPTR \
 449   (sizeof (void *) == sizeof (long) ? "lX" : \
 450    sizeof (void *) == sizeof (int) ? "X" : \
 451    "llX")
 452 #endif
 453
 454 /* @@ end of prolog @@ */
 455
 456 #ifdef _LIBC
 457 /* Rename the non ISO C functions.  This is required by the standard
 458    because some ISO C functions will require linking with this object
 459    file and the name space must not be polluted.  */
 460 # define open   __open
 461 # define close  __close
 462 # define read   __read
 463 # define mmap   __mmap
 464 # define munmap __munmap
 465 #endif
 466
 467 /* For those losing systems which don't have `alloca' we have to add
 468    some additional code emulating it.  */
 469 #ifdef HAVE_ALLOCA
 470 # define freea(p) /* nothing */
 471 #else
 472 # define alloca(n) malloc (n)
 473 # define freea(p) free (p)
 474 #endif
 475
 476 /* For systems that distinguish between text and binary I/O.
 477    O_BINARY is usually declared in <fcntl.h>. */
 478 #if !defined O_BINARY && defined _O_BINARY
 479   /* For MSC-compatible compilers.  */
 480 # define O_BINARY _O_BINARY
 481 # define O_TEXT _O_TEXT
 482 #endif
 483 #ifdef __BEOS__
 484   /* BeOS 5 has O_BINARY and O_TEXT, but they have no effect.  */
 485 # undef O_BINARY
 486 # undef O_TEXT
 487 #endif
 488 /* On reasonable systems, binary I/O is the default.  */
 489 #ifndef O_BINARY
 490 # define O_BINARY 0
 491 #endif
 492
 493
 494 /* We need a sign, whether a new catalog was loaded, which can be associated
 495    with all translations.  This is important if the translations are
 496    cached by one of GCC's features.  */
 497 int _nl_msg_cat_cntr;
 498
 499
 500 /* Expand a system dependent string segment.  Return NULL if unsupported.  */
 501 static const char *
 502 get_sysdep_segment_value (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   /* Test for a glibc specific printf() format directive flag.  */
 752   if (name[0] == 'I' && name[1] == '\0')
 753     {
 754 #if defined _LIBC || __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
 755       /* The 'I' flag, in numeric format directives, replaces ASCII digits
 756          with the 'outdigits' defined in the LC_CTYPE locale facet.  This is
 757          used for Farsi (Persian) and maybe Arabic.  */
 758       return "I";
 759 #else
 760       return "";
 761 #endif
 762     }
 763   /* Other system dependent strings are not valid.  */
 764   return NULL;
 765 }
 766
 767 /* Initialize the codeset dependent parts of an opened message catalog.
 768    Return the header entry.  */
 769 const char *
 770 internal_function
 771 _nl_init_domain_conv (struct loaded_l10nfile *domain_file,
 772                       struct loaded_domain *domain,
 773                       struct binding *domainbinding)
 774 {
 775   /* Find out about the character set the file is encoded with.
 776      This can be found (in textual form) in the entry "".  If this
 777      entry does not exist or if this does not contain the `charset='
 778      information, we will assume the charset matches the one the
 779      current locale and we don't have to perform any conversion.  */
 780   char *nullentry;
 781   size_t nullentrylen;
 782
 783   /* Preinitialize fields, to avoid recursion during _nl_find_msg.  */
 784   domain->codeset_cntr =
 785     (domainbinding != NULL ? domainbinding->codeset_cntr : 0);
 786 #ifdef _LIBC
 787   domain->conv = (__gconv_t) -1;
 788 #else
 789 # if HAVE_ICONV
 790   domain->conv = (iconv_t) -1;
 791 # endif
 792 #endif
 793   domain->conv_tab = NULL;
 794
 795   /* Get the header entry.  */
 796   nullentry = _nl_find_msg (domain_file, domainbinding, "", &nullentrylen);
 797
 798   if (nullentry != NULL)
 799     {
 800 #if defined _LIBC || HAVE_ICONV
 801       const char *charsetstr;
 802
 803       charsetstr = strstr (nullentry, "charset=");
 804       if (charsetstr != NULL)
 805         {
 806           size_t len;
 807           char *charset;
 808           const char *outcharset;
 809
 810           charsetstr += strlen ("charset=");
 811           len = strcspn (charsetstr, " \t\n");
 812
 813           charset = (char *) alloca (len + 1);
 814 # if defined _LIBC || HAVE_MEMPCPY
 815           *((char *) mempcpy (charset, charsetstr, len)) = '\0';
 816 # else
 817           memcpy (charset, charsetstr, len);
 818           charset[len] = '\0';
 819 # endif
 820
 821           /* The output charset should normally be determined by the
 822              locale.  But sometimes the locale is not used or not correctly
 823              set up, so we provide a possibility for the user to override
 824              this.  Moreover, the value specified through
 825              bind_textdomain_codeset overrides both.  */
 826           if (domainbinding != NULL && domainbinding->codeset != NULL)
 827             outcharset = domainbinding->codeset;
 828           else
 829             {
 830               outcharset = getenv ("OUTPUT_CHARSET");
 831               if (outcharset == NULL || outcharset[0] == '\0')
 832                 {
 833 # ifdef _LIBC
 834                   outcharset = _NL_CURRENT (LC_CTYPE, CODESET);
 835 # else
 836 #  if HAVE_ICONV
 837                   extern const char *locale_charset (void);
 838                   outcharset = locale_charset ();
 839 #  endif
 840 # endif
 841                 }
 842             }
 843
 844 # ifdef _LIBC
 845           /* We always want to use transliteration.  */
 846           outcharset = norm_add_slashes (outcharset, "TRANSLIT");
 847           charset = norm_add_slashes (charset, NULL);
 848           if (__gconv_open (outcharset, charset, &domain->conv,
 849                             GCONV_AVOID_NOCONV)
 850               != __GCONV_OK)
 851             domain->conv = (__gconv_t) -1;
 852 # else
 853 #  if HAVE_ICONV
 854           /* When using GNU libc >= 2.2 or GNU libiconv >= 1.5,
 855              we want to use transliteration.  */
 856 #   if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2) || __GLIBC__ > 2 \
 857        || _LIBICONV_VERSION >= 0x0105
 858           if (strchr (outcharset, '/') == NULL)
 859             {
 860               char *tmp;
 861
 862               len = strlen (outcharset);
 863               tmp = (char *) alloca (len + 10 + 1);
 864               memcpy (tmp, outcharset, len);
 865               memcpy (tmp + len, "//TRANSLIT", 10 + 1);
 866               outcharset = tmp;
 867
 868               domain->conv = iconv_open (outcharset, charset);
 869
 870               freea (outcharset);
 871             }
 872           else
 873 #   endif
 874             domain->conv = iconv_open (outcharset, charset);
 875 #  endif
 876 # endif
 877
 878           freea (charset);
 879         }
 880 #endif /* _LIBC || HAVE_ICONV */
 881     }
 882
 883   return nullentry;
 884 }
 885
 886 /* Frees the codeset dependent parts of an opened message catalog.  */
 887 void
 888 internal_function
 889 _nl_free_domain_conv (struct loaded_domain *domain)
 890 {
 891   if (domain->conv_tab != NULL && domain->conv_tab != (char **) -1)
 892     free (domain->conv_tab);
 893
 894 #ifdef _LIBC
 895   if (domain->conv != (__gconv_t) -1)
 896     __gconv_close (domain->conv);
 897 #else
 898 # if HAVE_ICONV
 899   if (domain->conv != (iconv_t) -1)
 900     iconv_close (domain->conv);
 901 # endif
 902 #endif
 903 }
 904
 905 /* Load the message catalogs specified by FILENAME.  If it is no valid
 906    message catalog do nothing.  */
 907 void
 908 internal_function
 909 _nl_load_domain (struct loaded_l10nfile *domain_file,
 910                  struct binding *domainbinding)
 911 {
 912   int fd;
 913   size_t size;
 914 #ifdef _LIBC
 915   struct stat64 st;
 916 #else
 917   struct stat st;
 918 #endif
 919   struct mo_file_header *data = (struct mo_file_header *) -1;
 920   int use_mmap = 0;
 921   struct loaded_domain *domain;
 922   int revision;
 923   const char *nullentry;
 924
 925   domain_file->decided = 1;
 926   domain_file->data = NULL;
 927
 928   /* Note that it would be useless to store domainbinding in domain_file
 929      because domainbinding might be == NULL now but != NULL later (after
 930      a call to bind_textdomain_codeset).  */
 931
 932   /* If the record does not represent a valid locale the FILENAME
 933      might be NULL.  This can happen when according to the given
 934      specification the locale file name is different for XPG and CEN
 935      syntax.  */
 936   if (domain_file->filename == NULL)
 937     return;
 938
 939   /* Try to open the addressed file.  */
 940   fd = open (domain_file->filename, O_RDONLY | O_BINARY);
 941   if (fd == -1)
 942     return;
 943
 944   /* We must know about the size of the file.  */
 945   if (
 946 #ifdef _LIBC
 947       __builtin_expect (fstat64 (fd, &st) != 0, 0)
 948 #else
 949       __builtin_expect (fstat (fd, &st) != 0, 0)
 950 #endif
 951       || __builtin_expect ((size = (size_t) st.st_size) != st.st_size, 0)
 952       || __builtin_expect (size < sizeof (struct mo_file_header), 0))
 953     {
 954       /* Something went wrong.  */
 955       close (fd);
 956       return;
 957     }
 958
 959 #ifdef HAVE_MMAP
 960   /* Now we are ready to load the file.  If mmap() is available we try
 961      this first.  If not available or it failed we try to load it.  */
 962   data = (struct mo_file_header *) mmap (NULL, size, PROT_READ,
 963                                          MAP_PRIVATE, fd, 0);
 964
 965   if (__builtin_expect (data != (struct mo_file_header *) -1, 1))
 966     {
 967       /* mmap() call was successful.  */
 968       close (fd);
 969       use_mmap = 1;
 970     }
 971 #endif
 972
 973   /* If the data is not yet available (i.e. mmap'ed) we try to load
 974      it manually.  */
 975   if (data == (struct mo_file_header *) -1)
 976     {
 977       size_t to_read;
 978       char *read_ptr;
 979
 980       data = (struct mo_file_header *) malloc (size);
 981       if (data == NULL)
 982         return;
 983
 984       to_read = size;
 985       read_ptr = (char *) data;
 986       do
 987         {
 988           long int nb = (long int) read (fd, read_ptr, to_read);
 989           if (nb <= 0)
 990             {
 991 #ifdef EINTR
 992               if (nb == -1 && errno == EINTR)
 993                 continue;
 994 #endif
 995               close (fd);
 996               return;
 997             }
 998           read_ptr += nb;
 999           to_read -= nb;
1000         }
1001       while (to_read > 0);
1002
1003       close (fd);
1004     }
1005
1006   /* Using the magic number we can test whether it really is a message
1007      catalog file.  */
1008   if (__builtin_expect (data->magic != _MAGIC && data->magic != _MAGIC_SWAPPED,
1009                         0))
1010     {
1011       /* The magic number is wrong: not a message catalog file.  */
1012 #ifdef HAVE_MMAP
1013       if (use_mmap)
1014         munmap ((caddr_t) data, size);
1015       else
1016 #endif
1017         free (data);
1018       return;
1019     }
1020
1021   domain = (struct loaded_domain *) malloc (sizeof (struct loaded_domain));
1022   if (domain == NULL)
1023     return;
1024   domain_file->data = domain;
1025
1026   domain->data = (char *) data;
1027   domain->use_mmap = use_mmap;
1028   domain->mmap_size = size;
1029   domain->must_swap = data->magic != _MAGIC;
1030   domain->malloced = NULL;
1031
1032   /* Fill in the information about the available tables.  */
1033   revision = W (domain->must_swap, data->revision);
1034   /* We support only the major revisions 0 and 1.  */
1035   switch (revision >> 16)
1036     {
1037     case 0:
1038     case 1:
1039       domain->nstrings = W (domain->must_swap, data->nstrings);
1040       domain->orig_tab = (const struct string_desc *)
1041         ((char *) data + W (domain->must_swap, data->orig_tab_offset));
1042       domain->trans_tab = (const struct string_desc *)
1043         ((char *) data + W (domain->must_swap, data->trans_tab_offset));
1044       domain->hash_size = W (domain->must_swap, data->hash_tab_size);
1045       domain->hash_tab =
1046         (domain->hash_size > 2
1047          ? (const nls_uint32 *)
1048            ((char *) data + W (domain->must_swap, data->hash_tab_offset))
1049          : NULL);
1050       domain->must_swap_hash_tab = domain->must_swap;
1051
1052       /* Now dispatch on the minor revision.  */
1053       switch (revision & 0xffff)
1054         {
1055         case 0:
1056           domain->n_sysdep_strings = 0;
1057           domain->orig_sysdep_tab = NULL;
1058           domain->trans_sysdep_tab = NULL;
1059           break;
1060         case 1:
1061         default:
1062           {
1063             nls_uint32 n_sysdep_strings;
1064
1065             if (domain->hash_tab == NULL)
1066               /* This is invalid.  These minor revisions need a hash table.  */
1067               goto invalid;
1068
1069             n_sysdep_strings =
1070               W (domain->must_swap, data->n_sysdep_strings);
1071             if (n_sysdep_strings > 0)
1072               {
1073                 nls_uint32 n_sysdep_segments;
1074                 const struct sysdep_segment *sysdep_segments;
1075                 const char **sysdep_segment_values;
1076                 const nls_uint32 *orig_sysdep_tab;
1077                 const nls_uint32 *trans_sysdep_tab;
1078                 nls_uint32 n_inmem_sysdep_strings;
1079                 size_t memneed;
1080                 char *mem;
1081                 struct sysdep_string_desc *inmem_orig_sysdep_tab;
1082                 struct sysdep_string_desc *inmem_trans_sysdep_tab;
1083                 nls_uint32 *inmem_hash_tab;
1084                 unsigned int i, j;
1085
1086                 /* Get the values of the system dependent segments.  */
1087                 n_sysdep_segments =
1088                   W (domain->must_swap, data->n_sysdep_segments);
1089                 sysdep_segments = (const struct sysdep_segment *)
1090                   ((char *) data
1091                    + W (domain->must_swap, data->sysdep_segments_offset));
1092                 sysdep_segment_values =
1093                   alloca (n_sysdep_segments * sizeof (const char *));
1094                 for (i = 0; i < n_sysdep_segments; i++)
1095                   {
1096                     const char *name =
1097                       (char *) data
1098                       + W (domain->must_swap, sysdep_segments[i].offset);
1099                     nls_uint32 namelen =
1100                       W (domain->must_swap, sysdep_segments[i].length);
1101
1102                     if (!(namelen > 0 && name[namelen - 1] == '\0'))
1103                       {
1104                         freea (sysdep_segment_values);
1105                         goto invalid;
1106                       }
1107
1108                     sysdep_segment_values[i] = get_sysdep_segment_value (name);
1109                   }
1110
1111                 orig_sysdep_tab = (const nls_uint32 *)
1112                   ((char *) data
1113                    + W (domain->must_swap, data->orig_sysdep_tab_offset));
1114                 trans_sysdep_tab = (const nls_uint32 *)
1115                   ((char *) data
1116                    + W (domain->must_swap, data->trans_sysdep_tab_offset));
1117
1118                 /* Compute the amount of additional memory needed for the
1119                    system dependent strings and the augmented hash table.
1120                    At the same time, also drop string pairs which refer to
1121                    an undefined system dependent segment.  */
1122                 n_inmem_sysdep_strings = 0;
1123                 memneed = domain->hash_size * sizeof (nls_uint32);
1124                 for (i = 0; i < n_sysdep_strings; i++)
1125                   {
1126                     int valid = 1;
1127                     size_t needs[2];
1128
1129                     for (j = 0; j < 2; j++)
1130                       {
1131                         const struct sysdep_string *sysdep_string =
1132                           (const struct sysdep_string *)
1133                           ((char *) data
1134                            + W (domain->must_swap,
1135                                 j == 0
1136                                 ? orig_sysdep_tab[i]
1137                                 : trans_sysdep_tab[i]));
1138                         size_t need = 0;
1139                         const struct segment_pair *p = sysdep_string->segments;
1140
1141                         if (W (domain->must_swap, p->sysdepref) != SEGMENTS_END)
1142                           for (p = sysdep_string->segments;; p++)
1143                             {
1144                               nls_uint32 sysdepref;
1145
1146                               need += W (domain->must_swap, p->segsize);
1147
1148                               sysdepref = W (domain->must_swap, p->sysdepref);
1149                               if (sysdepref == SEGMENTS_END)
1150                                 break;
1151
1152                               if (sysdepref >= n_sysdep_segments)
1153                                 {
1154                                   /* Invalid.  */
1155                                   freea (sysdep_segment_values);
1156                                   goto invalid;
1157                                 }
1158
1159                               if (sysdep_segment_values[sysdepref] == NULL)
1160                                 {
1161                                   /* This particular string pair is invalid.  */
1162                                   valid = 0;
1163                                   break;
1164                                 }
1165
1166                               need += strlen (sysdep_segment_values[sysdepref]);
1167                             }
1168
1169                         needs[j] = need;
1170                         if (!valid)
1171                           break;
1172                       }
1173
1174                     if (valid)
1175                       {
1176                         n_inmem_sysdep_strings++;
1177                         memneed += needs[0] + needs[1];
1178                       }
1179                   }
1180                 memneed += 2 * n_inmem_sysdep_strings
1181                            * sizeof (struct sysdep_string_desc);
1182
1183                 if (n_inmem_sysdep_strings > 0)
1184                   {
1185                     unsigned int k;
1186
1187                     /* Allocate additional memory.  */
1188                     mem = (char *) malloc (memneed);
1189                     if (mem == NULL)
1190                       goto invalid;
1191
1192                     domain->malloced = mem;
1193                     inmem_orig_sysdep_tab = (struct sysdep_string_desc *) mem;
1194                     mem += n_inmem_sysdep_strings
1195                            * sizeof (struct sysdep_string_desc);
1196                     inmem_trans_sysdep_tab = (struct sysdep_string_desc *) mem;
1197                     mem += n_inmem_sysdep_strings
1198                            * sizeof (struct sysdep_string_desc);
1199                     inmem_hash_tab = (nls_uint32 *) mem;
1200                     mem += domain->hash_size * sizeof (nls_uint32);
1201
1202                     /* Compute the system dependent strings.  */
1203                     k = 0;
1204                     for (i = 0; i < n_sysdep_strings; i++)
1205                       {
1206                         int valid = 1;
1207
1208                         for (j = 0; j < 2; j++)
1209                           {
1210                             const struct sysdep_string *sysdep_string =
1211                               (const struct sysdep_string *)
1212                               ((char *) data
1213                                + W (domain->must_swap,
1214                                     j == 0
1215                                     ? orig_sysdep_tab[i]
1216                                     : trans_sysdep_tab[i]));
1217                             const struct segment_pair *p =
1218                               sysdep_string->segments;
1219
1220                             if (W (domain->must_swap, p->sysdepref)
1221                                 != SEGMENTS_END)
1222                               for (p = sysdep_string->segments;; p++)
1223                                 {
1224                                   nls_uint32 sysdepref;
1225
1226                                   sysdepref =
1227                                     W (domain->must_swap, p->sysdepref);
1228                                   if (sysdepref == SEGMENTS_END)
1229                                     break;
1230
1231                                   if (sysdep_segment_values[sysdepref] == NULL)
1232                                     {
1233                                       /* This particular string pair is
1234                                          invalid.  */
1235                                       valid = 0;
1236                                       break;
1237                                     }
1238                                 }
1239
1240                             if (!valid)
1241                               break;
1242                           }
1243
1244                         if (valid)
1245                           {
1246                             for (j = 0; j < 2; j++)
1247                               {
1248                                 const struct sysdep_string *sysdep_string =
1249                                   (const struct sysdep_string *)
1250                                   ((char *) data
1251                                    + W (domain->must_swap,
1252                                         j == 0
1253                                         ? orig_sysdep_tab[i]
1254                                         : trans_sysdep_tab[i]));
1255                                 const char *static_segments =
1256                                   (char *) data
1257                                   + W (domain->must_swap, sysdep_string->offset);
1258                                 const struct segment_pair *p =
1259                                   sysdep_string->segments;
1260
1261                                 /* Concatenate the segments, and fill
1262                                    inmem_orig_sysdep_tab[k] (for j == 0) and
1263                                    inmem_trans_sysdep_tab[k] (for j == 1).  */
1264
1265                                 struct sysdep_string_desc *inmem_tab_entry =
1266                                   (j == 0
1267                                    ? inmem_orig_sysdep_tab
1268                                    : inmem_trans_sysdep_tab)
1269                                   + k;
1270
1271                                 if (W (domain->must_swap, p->sysdepref)
1272                                     == SEGMENTS_END)
1273                                   {
1274                                     /* Only one static segment.  */
1275                                     inmem_tab_entry->length =
1276                                       W (domain->must_swap, p->segsize);
1277                                     inmem_tab_entry->pointer = static_segments;
1278                                   }
1279                                 else
1280                                   {
1281                                     inmem_tab_entry->pointer = mem;
1282
1283                                     for (p = sysdep_string->segments;; p++)
1284                                       {
1285                                         nls_uint32 segsize =
1286                                           W (domain->must_swap, p->segsize);
1287                                         nls_uint32 sysdepref =
1288                                           W (domain->must_swap, p->sysdepref);
1289                                         size_t n;
1290
1291                                         if (segsize > 0)
1292                                           {
1293                                             memcpy (mem, static_segments, segsize);
1294                                             mem += segsize;
1295                                             static_segments += segsize;
1296                                           }
1297
1298                                         if (sysdepref == SEGMENTS_END)
1299                                           break;
1300
1301                                         n = strlen (sysdep_segment_values[sysdepref]);
1302                                         memcpy (mem, sysdep_segment_values[sysdepref], n);
1303                                         mem += n;
1304                                       }
1305
1306                                     inmem_tab_entry->length =
1307                                       mem - inmem_tab_entry->pointer;
1308                                   }
1309                               }
1310
1311                             k++;
1312                           }
1313                       }
1314                     if (k != n_inmem_sysdep_strings)
1315                       abort ();
1316
1317                     /* Compute the augmented hash table.  */
1318                     for (i = 0; i < domain->hash_size; i++)
1319                       inmem_hash_tab[i] =
1320                         W (domain->must_swap_hash_tab, domain->hash_tab[i]);
1321                     for (i = 0; i < n_inmem_sysdep_strings; i++)
1322                       {
1323                         const char *msgid = inmem_orig_sysdep_tab[i].pointer;
1324                         nls_uint32 hash_val = hash_string (msgid);
1325                         nls_uint32 idx = hash_val % domain->hash_size;
1326                         nls_uint32 incr =
1327                           1 + (hash_val % (domain->hash_size - 2));
1328
1329                         for (;;)
1330                           {
1331                             if (inmem_hash_tab[idx] == 0)
1332                               {
1333                                 /* Hash table entry is empty.  Use it.  */
1334                                 inmem_hash_tab[idx] = 1 + domain->nstrings + i;
1335                                 break;
1336                               }
1337
1338                             if (idx >= domain->hash_size - incr)
1339                               idx -= domain->hash_size - incr;
1340                             else
1341                               idx += incr;
1342                           }
1343                       }
1344
1345                     domain->n_sysdep_strings = n_inmem_sysdep_strings;
1346                     domain->orig_sysdep_tab = inmem_orig_sysdep_tab;
1347                     domain->trans_sysdep_tab = inmem_trans_sysdep_tab;
1348
1349                     domain->hash_tab = inmem_hash_tab;
1350                     domain->must_swap_hash_tab = 0;
1351                   }
1352                 else
1353                   {
1354                     domain->n_sysdep_strings = 0;
1355                     domain->orig_sysdep_tab = NULL;
1356                     domain->trans_sysdep_tab = NULL;
1357                   }
1358
1359                 freea (sysdep_segment_values);
1360               }
1361             else
1362               {
1363                 domain->n_sysdep_strings = 0;
1364                 domain->orig_sysdep_tab = NULL;
1365                 domain->trans_sysdep_tab = NULL;
1366               }
1367           }
1368           break;
1369         }
1370       break;
1371     default:
1372       /* This is an invalid revision.  */
1373     invalid:
1374       /* This is an invalid .mo file.  */
1375       if (domain->malloced)
1376         free (domain->malloced);
1377 #ifdef HAVE_MMAP
1378       if (use_mmap)
1379         munmap ((caddr_t) data, size);
1380       else
1381 #endif
1382         free (data);
1383       free (domain);
1384       domain_file->data = NULL;
1385       return;
1386     }
1387
1388   /* Now initialize the character set converter from the character set
1389      the file is encoded with (found in the header entry) to the domain's
1390      specified character set or the locale's character set.  */
1391   nullentry = _nl_init_domain_conv (domain_file, domain, domainbinding);
1392
1393   /* Also look for a plural specification.  */
1394   EXTRACT_PLURAL_EXPRESSION (nullentry, &domain->plural, &domain->nplurals);
1395 }
1396
1397
1398 #ifdef _LIBC
1399 void
1400 internal_function
1401 _nl_unload_domain (struct loaded_domain *domain)
1402 {
1403   if (domain->plural != &__gettext_germanic_plural)
1404     __gettext_free_exp (domain->plural);
1405
1406   _nl_free_domain_conv (domain);
1407
1408   if (domain->malloced)
1409     free (domain->malloced);
1410
1411 # ifdef _POSIX_MAPPED_FILES
1412   if (domain->use_mmap)
1413     munmap ((caddr_t) domain->data, domain->mmap_size);
1414   else
1415 # endif /* _POSIX_MAPPED_FILES */
1416     free ((void *) domain->data);
1417
1418   free (domain);
1419 }
1420 #endif