1 /* Load needed message catalogs. 2 Copyright (C) 1995-1999, 2000-2003 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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, 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 /* Prototypes for local functions. Needed to ensure compiler checking of 495 function argument counts despite of K&R C function definition syntax. */ 496 static const char *get_sysdep_segment_value PARAMS ((const char *name)); 497 498 499 /* We need a sign, whether a new catalog was loaded, which can be associated 500 with all translations. This is important if the translations are 501 cached by one of GCC's features. */ 502 int _nl_msg_cat_cntr; 503 504 505 /* Expand a system dependent string segment. Return NULL if unsupported. */ 506 static const char * 507 get_sysdep_segment_value (name) 508 const char *name; 509 { 510 /* Test for an ISO C 99 section 7.8.1 format string directive. 511 Syntax: 512 P R I { d | i | o | u | x | X } 513 { { | LEAST | FAST } { 8 | 16 | 32 | 64 } | MAX | PTR } */ 514 /* We don't use a table of 14 times 6 'const char *' strings here, because 515 data relocations cost startup time. */ 516 if (name[0] == 'P' && name[1] == 'R' && name[2] == 'I') 517 { 518 if (name[3] == 'd' || name[3] == 'i' || name[3] == 'o' || name[3] == 'u' 519 || name[3] == 'x' || name[3] == 'X') 520 { 521 if (name[4] == '8' && name[5] == '\0') 522 { 523 if (name[3] == 'd') 524 return PRId8; 525 if (name[3] == 'i') 526 return PRIi8; 527 if (name[3] == 'o') 528 return PRIo8; 529 if (name[3] == 'u') 530 return PRIu8; 531 if (name[3] == 'x') 532 return PRIx8; 533 if (name[3] == 'X') 534 return PRIX8; 535 abort (); 536 } 537 if (name[4] == '1' && name[5] == '6' && name[6] == '\0') 538 { 539 if (name[3] == 'd') 540 return PRId16; 541 if (name[3] == 'i') 542 return PRIi16; 543 if (name[3] == 'o') 544 return PRIo16; 545 if (name[3] == 'u') 546 return PRIu16; 547 if (name[3] == 'x') 548 return PRIx16; 549 if (name[3] == 'X') 550 return PRIX16; 551 abort (); 552 } 553 if (name[4] == '3' && name[5] == '2' && name[6] == '\0') 554 { 555 if (name[3] == 'd') 556 return PRId32; 557 if (name[3] == 'i') 558 return PRIi32; 559 if (name[3] == 'o') 560 return PRIo32; 561 if (name[3] == 'u') 562 return PRIu32; 563 if (name[3] == 'x') 564 return PRIx32; 565 if (name[3] == 'X') 566 return PRIX32; 567 abort (); 568 } 569 if (name[4] == '6' && name[5] == '4' && name[6] == '\0') 570 { 571 if (name[3] == 'd') 572 return PRId64; 573 if (name[3] == 'i') 574 return PRIi64; 575 if (name[3] == 'o') 576 return PRIo64; 577 if (name[3] == 'u') 578 return PRIu64; 579 if (name[3] == 'x') 580 return PRIx64; 581 if (name[3] == 'X') 582 return PRIX64; 583 abort (); 584 } 585 if (name[4] == 'L' && name[5] == 'E' && name[6] == 'A' 586 && name[7] == 'S' && name[8] == 'T') 587 { 588 if (name[9] == '8' && name[10] == '\0') 589 { 590 if (name[3] == 'd') 591 return PRIdLEAST8; 592 if (name[3] == 'i') 593 return PRIiLEAST8; 594 if (name[3] == 'o') 595 return PRIoLEAST8; 596 if (name[3] == 'u') 597 return PRIuLEAST8; 598 if (name[3] == 'x') 599 return PRIxLEAST8; 600 if (name[3] == 'X') 601 return PRIXLEAST8; 602 abort (); 603 } 604 if (name[9] == '1' && name[10] == '6' && name[11] == '\0') 605 { 606 if (name[3] == 'd') 607 return PRIdLEAST16; 608 if (name[3] == 'i') 609 return PRIiLEAST16; 610 if (name[3] == 'o') 611 return PRIoLEAST16; 612 if (name[3] == 'u') 613 return PRIuLEAST16; 614 if (name[3] == 'x') 615 return PRIxLEAST16; 616 if (name[3] == 'X') 617 return PRIXLEAST16; 618 abort (); 619 } 620 if (name[9] == '3' && name[10] == '2' && name[11] == '\0') 621 { 622 if (name[3] == 'd') 623 return PRIdLEAST32; 624 if (name[3] == 'i') 625 return PRIiLEAST32; 626 if (name[3] == 'o') 627 return PRIoLEAST32; 628 if (name[3] == 'u') 629 return PRIuLEAST32; 630 if (name[3] == 'x') 631 return PRIxLEAST32; 632 if (name[3] == 'X') 633 return PRIXLEAST32; 634 abort (); 635 } 636 if (name[9] == '6' && name[10] == '4' && name[11] == '\0') 637 { 638 if (name[3] == 'd') 639 return PRIdLEAST64; 640 if (name[3] == 'i') 641 return PRIiLEAST64; 642 if (name[3] == 'o') 643 return PRIoLEAST64; 644 if (name[3] == 'u') 645 return PRIuLEAST64; 646 if (name[3] == 'x') 647 return PRIxLEAST64; 648 if (name[3] == 'X') 649 return PRIXLEAST64; 650 abort (); 651 } 652 } 653 if (name[4] == 'F' && name[5] == 'A' && name[6] == 'S' 654 && name[7] == 'T') 655 { 656 if (name[8] == '8' && name[9] == '\0') 657 { 658 if (name[3] == 'd') 659 return PRIdFAST8; 660 if (name[3] == 'i') 661 return PRIiFAST8; 662 if (name[3] == 'o') 663 return PRIoFAST8; 664 if (name[3] == 'u') 665 return PRIuFAST8; 666 if (name[3] == 'x') 667 return PRIxFAST8; 668 if (name[3] == 'X') 669 return PRIXFAST8; 670 abort (); 671 } 672 if (name[8] == '1' && name[9] == '6' && name[10] == '\0') 673 { 674 if (name[3] == 'd') 675 return PRIdFAST16; 676 if (name[3] == 'i') 677 return PRIiFAST16; 678 if (name[3] == 'o') 679 return PRIoFAST16; 680 if (name[3] == 'u') 681 return PRIuFAST16; 682 if (name[3] == 'x') 683 return PRIxFAST16; 684 if (name[3] == 'X') 685 return PRIXFAST16; 686 abort (); 687 } 688 if (name[8] == '3' && name[9] == '2' && name[10] == '\0') 689 { 690 if (name[3] == 'd') 691 return PRIdFAST32; 692 if (name[3] == 'i') 693 return PRIiFAST32; 694 if (name[3] == 'o') 695 return PRIoFAST32; 696 if (name[3] == 'u') 697 return PRIuFAST32; 698 if (name[3] == 'x') 699 return PRIxFAST32; 700 if (name[3] == 'X') 701 return PRIXFAST32; 702 abort (); 703 } 704 if (name[8] == '6' && name[9] == '4' && name[10] == '\0') 705 { 706 if (name[3] == 'd') 707 return PRIdFAST64; 708 if (name[3] == 'i') 709 return PRIiFAST64; 710 if (name[3] == 'o') 711 return PRIoFAST64; 712 if (name[3] == 'u') 713 return PRIuFAST64; 714 if (name[3] == 'x') 715 return PRIxFAST64; 716 if (name[3] == 'X') 717 return PRIXFAST64; 718 abort (); 719 } 720 } 721 if (name[4] == 'M' && name[5] == 'A' && name[6] == 'X' 722 && name[7] == '\0') 723 { 724 if (name[3] == 'd') 725 return PRIdMAX; 726 if (name[3] == 'i') 727 return PRIiMAX; 728 if (name[3] == 'o') 729 return PRIoMAX; 730 if (name[3] == 'u') 731 return PRIuMAX; 732 if (name[3] == 'x') 733 return PRIxMAX; 734 if (name[3] == 'X') 735 return PRIXMAX; 736 abort (); 737 } 738 if (name[4] == 'P' && name[5] == 'T' && name[6] == 'R' 739 && name[7] == '\0') 740 { 741 if (name[3] == 'd') 742 return PRIdPTR; 743 if (name[3] == 'i') 744 return PRIiPTR; 745 if (name[3] == 'o') 746 return PRIoPTR; 747 if (name[3] == 'u') 748 return PRIuPTR; 749 if (name[3] == 'x') 750 return PRIxPTR; 751 if (name[3] == 'X') 752 return PRIXPTR; 753 abort (); 754 } 755 } 756 } 757 /* Other system dependent strings are not valid. */ 758 return NULL; 759 } 760 761 /* Initialize the codeset dependent parts of an opened message catalog. 762 Return the header entry. */ 763 const char * 764 internal_function 765 _nl_init_domain_conv (domain_file, domain, domainbinding) 766 struct loaded_l10nfile *domain_file; 767 struct loaded_domain *domain; 768 struct binding *domainbinding; 769 { 770 /* Find out about the character set the file is encoded with. 771 This can be found (in textual form) in the entry "". If this 772 entry does not exist or if this does not contain the `charset=' 773 information, we will assume the charset matches the one the 774 current locale and we don't have to perform any conversion. */ 775 char *nullentry; 776 size_t nullentrylen; 777 778 /* Preinitialize fields, to avoid recursion during _nl_find_msg. */ 779 domain->codeset_cntr = 780 (domainbinding != NULL ? domainbinding->codeset_cntr : 0); 781 #ifdef _LIBC 782 domain->conv = (__gconv_t) -1; 783 #else 784 # if HAVE_ICONV 785 domain->conv = (iconv_t) -1; 786 # endif 787 #endif 788 domain->conv_tab = NULL; 789 790 /* Get the header entry. */ 791 nullentry = _nl_find_msg (domain_file, domainbinding, "", &nullentrylen); 792 793 if (nullentry != NULL) 794 { 795 #if defined _LIBC || HAVE_ICONV 796 const char *charsetstr; 797 798 charsetstr = strstr (nullentry, "charset="); 799 if (charsetstr != NULL) 800 { 801 size_t len; 802 char *charset; 803 const char *outcharset; 804 805 charsetstr += strlen ("charset="); 806 len = strcspn (charsetstr, " \t\n"); 807 808 charset = (char *) alloca (len + 1); 809 # if defined _LIBC || HAVE_MEMPCPY 810 *((char *) mempcpy (charset, charsetstr, len)) = '\0'; 811 # else 812 memcpy (charset, charsetstr, len); 813 charset[len] = '\0'; 814 # endif 815 816 /* The output charset should normally be determined by the 817 locale. But sometimes the locale is not used or not correctly 818 set up, so we provide a possibility for the user to override 819 this. Moreover, the value specified through 820 bind_textdomain_codeset overrides both. */ 821 if (domainbinding != NULL && domainbinding->codeset != NULL) 822 outcharset = domainbinding->codeset; 823 else 824 { 825 outcharset = getenv ("OUTPUT_CHARSET"); 826 if (outcharset == NULL || outcharset[0] == '\0') 827 { 828 # ifdef _LIBC 829 outcharset = _NL_CURRENT (LC_CTYPE, CODESET); 830 # else 831 # if HAVE_ICONV 832 extern const char *locale_charset PARAMS ((void)); 833 outcharset = locale_charset (); 834 # endif 835 # endif 836 } 837 } 838 839 # ifdef _LIBC 840 /* We always want to use transliteration. */ 841 outcharset = norm_add_slashes (outcharset, "TRANSLIT"); 842 charset = norm_add_slashes (charset, NULL); 843 if (__gconv_open (outcharset, charset, &domain->conv, 844 GCONV_AVOID_NOCONV) 845 != __GCONV_OK) 846 domain->conv = (__gconv_t) -1; 847 # else 848 # if HAVE_ICONV 849 /* When using GNU libc >= 2.2 or GNU libiconv >= 1.5, 850 we want to use transliteration. */ 851 # if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2) || __GLIBC__ > 2 \ 852 || _LIBICONV_VERSION >= 0x0105 853 if (strchr (outcharset, '/') == NULL) 854 { 855 char *tmp; 856 857 len = strlen (outcharset); 858 tmp = (char *) alloca (len + 10 + 1); 859 memcpy (tmp, outcharset, len); 860 memcpy (tmp + len, "//TRANSLIT", 10 + 1); 861 outcharset = tmp; 862 863 domain->conv = iconv_open (outcharset, charset); 864 865 freea (outcharset); 866 } 867 else 868 # endif 869 domain->conv = iconv_open (outcharset, charset); 870 # endif 871 # endif 872 873 freea (charset); 874 } 875 #endif /* _LIBC || HAVE_ICONV */ 876 } 877 878 return nullentry; 879 } 880 881 /* Frees the codeset dependent parts of an opened message catalog. */ 882 void 883 internal_function 884 _nl_free_domain_conv (domain) 885 struct loaded_domain *domain; 886 { 887 if (domain->conv_tab != NULL && domain->conv_tab != (char **) -1) 888 free (domain->conv_tab); 889 890 #ifdef _LIBC 891 if (domain->conv != (__gconv_t) -1) 892 __gconv_close (domain->conv); 893 #else 894 # if HAVE_ICONV 895 if (domain->conv != (iconv_t) -1) 896 iconv_close (domain->conv); 897 # endif 898 #endif 899 } 900 901 /* Load the message catalogs specified by FILENAME. If it is no valid 902 message catalog do nothing. */ 903 void 904 internal_function 905 _nl_load_domain (domain_file, domainbinding) 906 struct loaded_l10nfile *domain_file; 907 struct binding *domainbinding; 908 { 909 int fd; 910 size_t size; 911 #ifdef _LIBC 912 struct stat64 st; 913 #else 914 struct stat st; 915 #endif 916 struct mo_file_header *data = (struct mo_file_header *) -1; 917 int use_mmap = 0; 918 struct loaded_domain *domain; 919 int revision; 920 const char *nullentry; 921 922 domain_file->decided = 1; 923 domain_file->data = NULL; 924 925 /* Note that it would be useless to store domainbinding in domain_file 926 because domainbinding might be == NULL now but != NULL later (after 927 a call to bind_textdomain_codeset). */ 928 929 /* If the record does not represent a valid locale the FILENAME 930 might be NULL. This can happen when according to the given 931 specification the locale file name is different for XPG and CEN 932 syntax. */ 933 if (domain_file->filename == NULL) 934 return; 935 936 /* Try to open the addressed file. */ 937 fd = open (domain_file->filename, O_RDONLY | O_BINARY); 938 if (fd == -1) 939 return; 940 941 /* We must know about the size of the file. */ 942 if ( 943 #ifdef _LIBC 944 __builtin_expect (fstat64 (fd, &st) != 0, 0) 945 #else 946 __builtin_expect (fstat (fd, &st) != 0, 0) 947 #endif 948 || __builtin_expect ((size = (size_t) st.st_size) != st.st_size, 0) 949 || __builtin_expect (size < sizeof (struct mo_file_header), 0)) 950 { 951 /* Something went wrong. */ 952 close (fd); 953 return; 954 } 955 956 #ifdef HAVE_MMAP 957 /* Now we are ready to load the file. If mmap() is available we try 958 this first. If not available or it failed we try to load it. */ 959 data = (struct mo_file_header *) mmap (NULL, size, PROT_READ, 960 MAP_PRIVATE, fd, 0); 961 962 if (__builtin_expect (data != (struct mo_file_header *) -1, 1)) 963 { 964 /* mmap() call was successful. */ 965 close (fd); 966 use_mmap = 1; 967 } 968 #endif 969 970 /* If the data is not yet available (i.e. mmap'ed) we try to load 971 it manually. */ 972 if (data == (struct mo_file_header *) -1) 973 { 974 size_t to_read; 975 char *read_ptr; 976 977 data = (struct mo_file_header *) malloc (size); 978 if (data == NULL) 979 return; 980 981 to_read = size; 982 read_ptr = (char *) data; 983 do 984 { 985 long int nb = (long int) read (fd, read_ptr, to_read); 986 if (nb <= 0) 987 { 988 #ifdef EINTR 989 if (nb == -1 && errno == EINTR) 990 continue; 991 #endif 992 close (fd); 993 return; 994 } 995 read_ptr += nb; 996 to_read -= nb; 997 } 998 while (to_read > 0); 999 1000 close (fd); 1001 } 1002 1003 /* Using the magic number we can test whether it really is a message 1004 catalog file. */ 1005 if (__builtin_expect (data->magic != _MAGIC && data->magic != _MAGIC_SWAPPED, 1006 0)) 1007 { 1008 /* The magic number is wrong: not a message catalog file. */ 1009 #ifdef HAVE_MMAP 1010 if (use_mmap) 1011 munmap ((caddr_t) data, size); 1012 else 1013 #endif 1014 free (data); 1015 return; 1016 } 1017 1018 domain = (struct loaded_domain *) malloc (sizeof (struct loaded_domain)); 1019 if (domain == NULL) 1020 return; 1021 domain_file->data = domain; 1022 1023 domain->data = (char *) data; 1024 domain->use_mmap = use_mmap; 1025 domain->mmap_size = size; 1026 domain->must_swap = data->magic != _MAGIC; 1027 domain->malloced = NULL; 1028 1029 /* Fill in the information about the available tables. */ 1030 revision = W (domain->must_swap, data->revision); 1031 /* We support only the major revision 0. */ 1032 switch (revision >> 16) 1033 { 1034 case 0: 1035 domain->nstrings = W (domain->must_swap, data->nstrings); 1036 domain->orig_tab = (const struct string_desc *) 1037 ((char *) data + W (domain->must_swap, data->orig_tab_offset)); 1038 domain->trans_tab = (const struct string_desc *) 1039 ((char *) data + W (domain->must_swap, data->trans_tab_offset)); 1040 domain->hash_size = W (domain->must_swap, data->hash_tab_size); 1041 domain->hash_tab = 1042 (domain->hash_size > 2 1043 ? (const nls_uint32 *) 1044 ((char *) data + W (domain->must_swap, data->hash_tab_offset)) 1045 : NULL); 1046 domain->must_swap_hash_tab = domain->must_swap; 1047 1048 /* Now dispatch on the minor revision. */ 1049 switch (revision & 0xffff) 1050 { 1051 case 0: 1052 domain->n_sysdep_strings = 0; 1053 domain->orig_sysdep_tab = NULL; 1054 domain->trans_sysdep_tab = NULL; 1055 break; 1056 case 1: 1057 default: 1058 { 1059 nls_uint32 n_sysdep_strings; 1060 1061 if (domain->hash_tab == NULL) 1062 /* This is invalid. These minor revisions need a hash table. */ 1063 goto invalid; 1064 1065 n_sysdep_strings = 1066 W (domain->must_swap, data->n_sysdep_strings); 1067 if (n_sysdep_strings > 0) 1068 { 1069 nls_uint32 n_sysdep_segments; 1070 const struct sysdep_segment *sysdep_segments; 1071 const char **sysdep_segment_values; 1072 const nls_uint32 *orig_sysdep_tab; 1073 const nls_uint32 *trans_sysdep_tab; 1074 size_t memneed; 1075 char *mem; 1076 struct sysdep_string_desc *inmem_orig_sysdep_tab; 1077 struct sysdep_string_desc *inmem_trans_sysdep_tab; 1078 nls_uint32 *inmem_hash_tab; 1079 unsigned int i; 1080 1081 /* Get the values of the system dependent segments. */ 1082 n_sysdep_segments = 1083 W (domain->must_swap, data->n_sysdep_segments); 1084 sysdep_segments = (const struct sysdep_segment *) 1085 ((char *) data 1086 + W (domain->must_swap, data->sysdep_segments_offset)); 1087 sysdep_segment_values = 1088 alloca (n_sysdep_segments * sizeof (const char *)); 1089 for (i = 0; i < n_sysdep_segments; i++) 1090 { 1091 const char *name = 1092 (char *) data 1093 + W (domain->must_swap, sysdep_segments[i].offset); 1094 nls_uint32 namelen = 1095 W (domain->must_swap, sysdep_segments[i].length); 1096 1097 if (!(namelen > 0 && name[namelen - 1] == '\0')) 1098 { 1099 freea (sysdep_segment_values); 1100 goto invalid; 1101 } 1102 1103 sysdep_segment_values[i] = get_sysdep_segment_value (name); 1104 } 1105 1106 orig_sysdep_tab = (const nls_uint32 *) 1107 ((char *) data 1108 + W (domain->must_swap, data->orig_sysdep_tab_offset)); 1109 trans_sysdep_tab = (const nls_uint32 *) 1110 ((char *) data 1111 + W (domain->must_swap, data->trans_sysdep_tab_offset)); 1112 1113 /* Compute the amount of additional memory needed for the 1114 system dependent strings and the augmented hash table. */ 1115 memneed = 2 * n_sysdep_strings 1116 * sizeof (struct sysdep_string_desc) 1117 + domain->hash_size * sizeof (nls_uint32); 1118 for (i = 0; i < 2 * n_sysdep_strings; i++) 1119 { 1120 const struct sysdep_string *sysdep_string = 1121 (const struct sysdep_string *) 1122 ((char *) data 1123 + W (domain->must_swap, 1124 i < n_sysdep_strings 1125 ? orig_sysdep_tab[i] 1126 : trans_sysdep_tab[i - n_sysdep_strings])); 1127 size_t need = 0; 1128 const struct segment_pair *p = sysdep_string->segments; 1129 1130 if (W (domain->must_swap, p->sysdepref) != SEGMENTS_END) 1131 for (p = sysdep_string->segments;; p++) 1132 { 1133 nls_uint32 sysdepref; 1134 1135 need += W (domain->must_swap, p->segsize); 1136 1137 sysdepref = W (domain->must_swap, p->sysdepref); 1138 if (sysdepref == SEGMENTS_END) 1139 break; 1140 1141 if (sysdepref >= n_sysdep_segments) 1142 { 1143 /* Invalid. */ 1144 freea (sysdep_segment_values); 1145 goto invalid; 1146 } 1147 1148 need += strlen (sysdep_segment_values[sysdepref]); 1149 } 1150 1151 memneed += need; 1152 } 1153 1154 /* Allocate additional memory. */ 1155 mem = (char *) malloc (memneed); 1156 if (mem == NULL) 1157 goto invalid; 1158 1159 domain->malloced = mem; 1160 inmem_orig_sysdep_tab = (struct sysdep_string_desc *) mem; 1161 mem += n_sysdep_strings * sizeof (struct sysdep_string_desc); 1162 inmem_trans_sysdep_tab = (struct sysdep_string_desc *) mem; 1163 mem += n_sysdep_strings * sizeof (struct sysdep_string_desc); 1164 inmem_hash_tab = (nls_uint32 *) mem; 1165 mem += domain->hash_size * sizeof (nls_uint32); 1166 1167 /* Compute the system dependent strings. */ 1168 for (i = 0; i < 2 * n_sysdep_strings; i++) 1169 { 1170 const struct sysdep_string *sysdep_string = 1171 (const struct sysdep_string *) 1172 ((char *) data 1173 + W (domain->must_swap, 1174 i < n_sysdep_strings 1175 ? orig_sysdep_tab[i] 1176 : trans_sysdep_tab[i - n_sysdep_strings])); 1177 const char *static_segments = 1178 (char *) data 1179 + W (domain->must_swap, sysdep_string->offset); 1180 const struct segment_pair *p = sysdep_string->segments; 1181 1182 /* Concatenate the segments, and fill 1183 inmem_orig_sysdep_tab[i] (for i < n_sysdep_strings) and 1184 inmem_trans_sysdep_tab[i-n_sysdep_strings] (for 1185 i >= n_sysdep_strings). */ 1186 1187 if (W (domain->must_swap, p->sysdepref) == SEGMENTS_END) 1188 { 1189 /* Only one static segment. */ 1190 inmem_orig_sysdep_tab[i].length = 1191 W (domain->must_swap, p->segsize); 1192 inmem_orig_sysdep_tab[i].pointer = static_segments; 1193 } 1194 else 1195 { 1196 inmem_orig_sysdep_tab[i].pointer = mem; 1197 1198 for (p = sysdep_string->segments;; p++) 1199 { 1200 nls_uint32 segsize = 1201 W (domain->must_swap, p->segsize); 1202 nls_uint32 sysdepref = 1203 W (domain->must_swap, p->sysdepref); 1204 size_t n; 1205 1206 if (segsize > 0) 1207 { 1208 memcpy (mem, static_segments, segsize); 1209 mem += segsize; 1210 static_segments += segsize; 1211 } 1212 1213 if (sysdepref == SEGMENTS_END) 1214 break; 1215 1216 n = strlen (sysdep_segment_values[sysdepref]); 1217 memcpy (mem, sysdep_segment_values[sysdepref], n); 1218 mem += n; 1219 } 1220 1221 inmem_orig_sysdep_tab[i].length = 1222 mem - inmem_orig_sysdep_tab[i].pointer; 1223 } 1224 } 1225 1226 /* Compute the augmented hash table. */ 1227 for (i = 0; i < domain->hash_size; i++) 1228 inmem_hash_tab[i] = 1229 W (domain->must_swap_hash_tab, domain->hash_tab[i]); 1230 for (i = 0; i < n_sysdep_strings; i++) 1231 { 1232 const char *msgid = inmem_orig_sysdep_tab[i].pointer; 1233 nls_uint32 hash_val = hash_string (msgid); 1234 nls_uint32 idx = hash_val % domain->hash_size; 1235 nls_uint32 incr = 1 + (hash_val % (domain->hash_size - 2)); 1236 1237 for (;;) 1238 { 1239 if (inmem_hash_tab[idx] == 0) 1240 { 1241 /* Hash table entry is empty. Use it. */ 1242 inmem_hash_tab[idx] = 1 + domain->nstrings + i; 1243 break; 1244 } 1245 1246 if (idx >= domain->hash_size - incr) 1247 idx -= domain->hash_size - incr; 1248 else 1249 idx += incr; 1250 } 1251 } 1252 1253 freea (sysdep_segment_values); 1254 1255 domain->n_sysdep_strings = n_sysdep_strings; 1256 domain->orig_sysdep_tab = inmem_orig_sysdep_tab; 1257 domain->trans_sysdep_tab = inmem_trans_sysdep_tab; 1258 1259 domain->hash_tab = inmem_hash_tab; 1260 domain->must_swap_hash_tab = 0; 1261 } 1262 else 1263 { 1264 domain->n_sysdep_strings = 0; 1265 domain->orig_sysdep_tab = NULL; 1266 domain->trans_sysdep_tab = NULL; 1267 } 1268 } 1269 break; 1270 } 1271 break; 1272 default: 1273 /* This is an invalid revision. */ 1274 invalid: 1275 /* This is an invalid .mo file. */ 1276 if (domain->malloced) 1277 free (domain->malloced); 1278 #ifdef HAVE_MMAP 1279 if (use_mmap) 1280 munmap ((caddr_t) data, size); 1281 else 1282 #endif 1283 free (data); 1284 free (domain); 1285 domain_file->data = NULL; 1286 return; 1287 } 1288 1289 /* Now initialize the character set converter from the character set 1290 the file is encoded with (found in the header entry) to the domain's 1291 specified character set or the locale's character set. */ 1292 nullentry = _nl_init_domain_conv (domain_file, domain, domainbinding); 1293 1294 /* Also look for a plural specification. */ 1295 EXTRACT_PLURAL_EXPRESSION (nullentry, &domain->plural, &domain->nplurals); 1296 } 1297 1298 1299 #ifdef _LIBC 1300 void 1301 internal_function 1302 _nl_unload_domain (domain) 1303 struct loaded_domain *domain; 1304 { 1305 if (domain->plural != &__gettext_germanic_plural) 1306 __gettext_free_exp (domain->plural); 1307 1308 _nl_free_domain_conv (domain); 1309 1310 if (domain->malloced) 1311 free (domain->malloced); 1312 1313 # ifdef _POSIX_MAPPED_FILES 1314 if (domain->use_mmap) 1315 munmap ((caddr_t) domain->data, domain->mmap_size); 1316 else 1317 # endif /* _POSIX_MAPPED_FILES */ 1318 free ((void *) domain->data); 1319 1320 free (domain); 1321 } 1322 #endif 1323
