Home | History | Annotate | Download | only in intl
      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 ((void *) 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       free (domain->malloced);
   1376 #ifdef HAVE_MMAP
   1377       if (use_mmap)
   1378 	munmap ((void *) data, size);
   1379       else
   1380 #endif
   1381 	free (data);
   1382       free (domain);
   1383       domain_file->data = NULL;
   1384       return;
   1385     }
   1386 
   1387   /* Now initialize the character set converter from the character set
   1388      the file is encoded with (found in the header entry) to the domain's
   1389      specified character set or the locale's character set.  */
   1390   nullentry = _nl_init_domain_conv (domain_file, domain, domainbinding);
   1391 
   1392   /* Also look for a plural specification.  */
   1393   EXTRACT_PLURAL_EXPRESSION (nullentry, &domain->plural, &domain->nplurals);
   1394 }
   1395 
   1396 
   1397 #ifdef _LIBC
   1398 void
   1399 internal_function
   1400 _nl_unload_domain (struct loaded_domain *domain)
   1401 {
   1402   if (domain->plural != &__gettext_germanic_plural)
   1403     __gettext_free_exp (domain->plural);
   1404 
   1405   _nl_free_domain_conv (domain);
   1406 
   1407   free (domain->malloced);
   1408 
   1409 # ifdef _POSIX_MAPPED_FILES
   1410   if (domain->use_mmap)
   1411     munmap ((void *) domain->data, domain->mmap_size);
   1412   else
   1413 # endif	/* _POSIX_MAPPED_FILES */
   1414     free ((void *) domain->data);
   1415 
   1416   free (domain);
   1417 }
   1418 #endif
   1419