1/* Copyright (C) 1995-1999, 2000-2006 Free Software Foundation, Inc. 2 Contributed by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995. 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 stpcpy(). 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 <string.h> 31 32#if defined _LIBC || defined HAVE_ARGZ_H 33# include <argz.h> 34#endif 35#include <ctype.h> 36#include <sys/types.h> 37#include <stdlib.h> 38 39#include "loadinfo.h" 40 41/* On some strange systems still no definition of NULL is found. Sigh! */ 42#ifndef NULL 43# if defined __STDC__ && __STDC__ 44# define NULL ((void *) 0) 45# else 46# define NULL 0 47# endif 48#endif 49 50/* @@ end of prolog @@ */ 51 52#ifdef _LIBC 53/* Rename the non ANSI C functions. This is required by the standard 54 because some ANSI C functions will require linking with this object 55 file and the name space must not be polluted. */ 56# ifndef stpcpy 57# define stpcpy(dest, src) __stpcpy(dest, src) 58# endif 59#else 60# ifndef HAVE_STPCPY 61static char *stpcpy (char *dest, const char *src); 62# endif 63#endif 64 65/* Pathname support. 66 ISSLASH(C) tests whether C is a directory separator character. 67 IS_ABSOLUTE_PATH(P) tests whether P is an absolute path. If it is not, 68 it may be concatenated to a directory pathname. 69 */ 70#if defined _WIN32 || defined __WIN32__ || defined __CYGWIN__ || defined __EMX__ || defined __DJGPP__ 71 /* Win32, Cygwin, OS/2, DOS */ 72# define ISSLASH(C) ((C) == '/' || (C) == '\\') 73# define HAS_DEVICE(P) \ 74 ((((P)[0] >= 'A' && (P)[0] <= 'Z') || ((P)[0] >= 'a' && (P)[0] <= 'z')) \ 75 && (P)[1] == ':') 76# define IS_ABSOLUTE_PATH(P) (ISSLASH ((P)[0]) || HAS_DEVICE (P)) 77#else 78 /* Unix */ 79# define ISSLASH(C) ((C) == '/') 80# define IS_ABSOLUTE_PATH(P) ISSLASH ((P)[0]) 81#endif 82 83/* Define function which are usually not available. */ 84 85#ifdef _LIBC 86# define __argz_count(argz, len) INTUSE(__argz_count) (argz, len) 87#elif defined HAVE_ARGZ_COUNT 88# undef __argz_count 89# define __argz_count argz_count 90#else 91/* Returns the number of strings in ARGZ. */ 92static size_t 93argz_count__ (const char *argz, size_t len) 94{ 95 size_t count = 0; 96 while (len > 0) 97 { 98 size_t part_len = strlen (argz); 99 argz += part_len + 1; 100 len -= part_len + 1; 101 count++; 102 } 103 return count; 104} 105# undef __argz_count 106# define __argz_count(argz, len) argz_count__ (argz, len) 107#endif /* !_LIBC && !HAVE_ARGZ_COUNT */ 108 109#ifdef _LIBC 110# define __argz_stringify(argz, len, sep) \ 111 INTUSE(__argz_stringify) (argz, len, sep) 112#elif defined HAVE_ARGZ_STRINGIFY 113# undef __argz_stringify 114# define __argz_stringify argz_stringify 115#else 116/* Make '\0' separated arg vector ARGZ printable by converting all the '\0's 117 except the last into the character SEP. */ 118static void 119argz_stringify__ (char *argz, size_t len, int sep) 120{ 121 while (len > 0) 122 { 123 size_t part_len = strlen (argz); 124 argz += part_len; 125 len -= part_len + 1; 126 if (len > 0) 127 *argz++ = sep; 128 } 129} 130# undef __argz_stringify 131# define __argz_stringify(argz, len, sep) argz_stringify__ (argz, len, sep) 132#endif /* !_LIBC && !HAVE_ARGZ_STRINGIFY */ 133 134#ifdef _LIBC 135#elif defined HAVE_ARGZ_NEXT 136# undef __argz_next 137# define __argz_next argz_next 138#else 139static char * 140argz_next__ (char *argz, size_t argz_len, const char *entry) 141{ 142 if (entry) 143 { 144 if (entry < argz + argz_len) 145 entry = strchr (entry, '\0') + 1; 146 147 return entry >= argz + argz_len ? NULL : (char *) entry; 148 } 149 else 150 if (argz_len > 0) 151 return argz; 152 else 153 return 0; 154} 155# undef __argz_next 156# define __argz_next(argz, len, entry) argz_next__ (argz, len, entry) 157#endif /* !_LIBC && !HAVE_ARGZ_NEXT */ 158 159 160/* Return number of bits set in X. */ 161static inline int 162pop (int x) 163{ 164 /* We assume that no more than 16 bits are used. */ 165 x = ((x & ~0x5555) >> 1) + (x & 0x5555); 166 x = ((x & ~0x3333) >> 2) + (x & 0x3333); 167 x = ((x >> 4) + x) & 0x0f0f; 168 x = ((x >> 8) + x) & 0xff; 169 170 return x; 171} 172 173 174struct loaded_l10nfile * 175_nl_make_l10nflist (struct loaded_l10nfile **l10nfile_list, 176 const char *dirlist, size_t dirlist_len, 177 int mask, const char *language, const char *territory, 178 const char *codeset, const char *normalized_codeset, 179 const char *modifier, 180 const char *filename, int do_allocate) 181{ 182 char *abs_filename; 183 struct loaded_l10nfile **lastp; 184 struct loaded_l10nfile *retval; 185 char *cp; 186 size_t dirlist_count; 187 size_t entries; 188 int cnt; 189 190 /* If LANGUAGE contains an absolute directory specification, we ignore 191 DIRLIST. */ 192 if (IS_ABSOLUTE_PATH (language)) 193 dirlist_len = 0; 194 195 /* Allocate room for the full file name. */ 196 abs_filename = (char *) malloc (dirlist_len 197 + strlen (language) 198 + ((mask & XPG_TERRITORY) != 0 199 ? strlen (territory) + 1 : 0) 200 + ((mask & XPG_CODESET) != 0 201 ? strlen (codeset) + 1 : 0) 202 + ((mask & XPG_NORM_CODESET) != 0 203 ? strlen (normalized_codeset) + 1 : 0) 204 + ((mask & XPG_MODIFIER) != 0 205 ? strlen (modifier) + 1 : 0) 206 + 1 + strlen (filename) + 1); 207 208 if (abs_filename == NULL) 209 return NULL; 210 211 /* Construct file name. */ 212 cp = abs_filename; 213 if (dirlist_len > 0) 214 { 215 memcpy (cp, dirlist, dirlist_len); 216 __argz_stringify (cp, dirlist_len, PATH_SEPARATOR); 217 cp += dirlist_len; 218 cp[-1] = '/'; 219 } 220 221 cp = stpcpy (cp, language); 222 223 if ((mask & XPG_TERRITORY) != 0) 224 { 225 *cp++ = '_'; 226 cp = stpcpy (cp, territory); 227 } 228 if ((mask & XPG_CODESET) != 0) 229 { 230 *cp++ = '.'; 231 cp = stpcpy (cp, codeset); 232 } 233 if ((mask & XPG_NORM_CODESET) != 0) 234 { 235 *cp++ = '.'; 236 cp = stpcpy (cp, normalized_codeset); 237 } 238 if ((mask & XPG_MODIFIER) != 0) 239 { 240 *cp++ = '@'; 241 cp = stpcpy (cp, modifier); 242 } 243 244 *cp++ = '/'; 245 stpcpy (cp, filename); 246 247 /* Look in list of already loaded domains whether it is already 248 available. */ 249 lastp = l10nfile_list; 250 for (retval = *l10nfile_list; retval != NULL; retval = retval->next) 251 if (retval->filename != NULL) 252 { 253 int compare = strcmp (retval->filename, abs_filename); 254 if (compare == 0) 255 /* We found it! */ 256 break; 257 if (compare < 0) 258 { 259 /* It's not in the list. */ 260 retval = NULL; 261 break; 262 } 263 264 lastp = &retval->next; 265 } 266 267 if (retval != NULL || do_allocate == 0) 268 { 269 free (abs_filename); 270 return retval; 271 } 272 273 dirlist_count = (dirlist_len > 0 ? __argz_count (dirlist, dirlist_len) : 1); 274 275 /* Allocate a new loaded_l10nfile. */ 276 retval = 277 (struct loaded_l10nfile *) 278 malloc (sizeof (*retval) 279 + (((dirlist_count << pop (mask)) + (dirlist_count > 1 ? 1 : 0)) 280 * sizeof (struct loaded_l10nfile *))); 281 if (retval == NULL) 282 { 283 free (abs_filename); 284 return NULL; 285 } 286 287 retval->filename = abs_filename; 288 289 /* We set retval->data to NULL here; it is filled in later. 290 Setting retval->decided to 1 here means that retval does not 291 correspond to a real file (dirlist_count > 1) or is not worth 292 looking up (if an unnormalized codeset was specified). */ 293 retval->decided = (dirlist_count > 1 294 || ((mask & XPG_CODESET) != 0 295 && (mask & XPG_NORM_CODESET) != 0)); 296 retval->data = NULL; 297 298 retval->next = *lastp; 299 *lastp = retval; 300 301 entries = 0; 302 /* Recurse to fill the inheritance list of RETVAL. 303 If the DIRLIST is a real list (i.e. DIRLIST_COUNT > 1), the RETVAL 304 entry does not correspond to a real file; retval->filename contains 305 colons. In this case we loop across all elements of DIRLIST and 306 across all bit patterns dominated by MASK. 307 If the DIRLIST is a single directory or entirely redundant (i.e. 308 DIRLIST_COUNT == 1), we loop across all bit patterns dominated by 309 MASK, excluding MASK itself. 310 In either case, we loop down from MASK to 0. This has the effect 311 that the extra bits in the locale name are dropped in this order: 312 first the modifier, then the territory, then the codeset, then the 313 normalized_codeset. */ 314 for (cnt = dirlist_count > 1 ? mask : mask - 1; cnt >= 0; --cnt) 315 if ((cnt & ~mask) == 0 316 && !((cnt & XPG_CODESET) != 0 && (cnt & XPG_NORM_CODESET) != 0)) 317 { 318 if (dirlist_count > 1) 319 { 320 /* Iterate over all elements of the DIRLIST. */ 321 char *dir = NULL; 322 323 while ((dir = __argz_next ((char *) dirlist, dirlist_len, dir)) 324 != NULL) 325 retval->successor[entries++] 326 = _nl_make_l10nflist (l10nfile_list, dir, strlen (dir) + 1, 327 cnt, language, territory, codeset, 328 normalized_codeset, modifier, filename, 329 1); 330 } 331 else 332 retval->successor[entries++] 333 = _nl_make_l10nflist (l10nfile_list, dirlist, dirlist_len, 334 cnt, language, territory, codeset, 335 normalized_codeset, modifier, filename, 1); 336 } 337 retval->successor[entries] = NULL; 338 339 return retval; 340} 341 342/* Normalize codeset name. There is no standard for the codeset 343 names. Normalization allows the user to use any of the common 344 names. The return value is dynamically allocated and has to be 345 freed by the caller. */ 346const char * 347_nl_normalize_codeset (const char *codeset, size_t name_len) 348{ 349 int len = 0; 350 int only_digit = 1; 351 char *retval; 352 char *wp; 353 size_t cnt; 354 355 for (cnt = 0; cnt < name_len; ++cnt) 356 if (isalnum ((unsigned char) codeset[cnt])) 357 { 358 ++len; 359 360 if (isalpha ((unsigned char) codeset[cnt])) 361 only_digit = 0; 362 } 363 364 retval = (char *) malloc ((only_digit ? 3 : 0) + len + 1); 365 366 if (retval != NULL) 367 { 368 if (only_digit) 369 wp = stpcpy (retval, "iso"); 370 else 371 wp = retval; 372 373 for (cnt = 0; cnt < name_len; ++cnt) 374 if (isalpha ((unsigned char) codeset[cnt])) 375 *wp++ = tolower ((unsigned char) codeset[cnt]); 376 else if (isdigit ((unsigned char) codeset[cnt])) 377 *wp++ = codeset[cnt]; 378 379 *wp = '\0'; 380 } 381 382 return (const char *) retval; 383} 384 385 386/* @@ begin of epilog @@ */ 387 388/* We don't want libintl.a to depend on any other library. So we 389 avoid the non-standard function stpcpy. In GNU C Library this 390 function is available, though. Also allow the symbol HAVE_STPCPY 391 to be defined. */ 392#if !_LIBC && !HAVE_STPCPY 393static char * 394stpcpy (char *dest, const char *src) 395{ 396 while ((*dest++ = *src++) != '\0') 397 /* Do nothing. */ ; 398 return dest - 1; 399} 400#endif 401