locale/programs/locfile.c

   1 /* Copyright (C) 1996,1997,1998,1999,2000,2001 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Ulrich Drepper <drepper@gnu.org>, 1996.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Library General Public License as
   7    published by the Free Software Foundation; either version 2 of the
   8    License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Library General Public License for more details.
  14
  15    You should have received a copy of the GNU Library General Public
  16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
  17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18    Boston, MA 02111-1307, USA.  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 # include <config.h>
  22 #endif
  23
  24 #include <errno.h>
  25 #include <fcntl.h>
  26 #include <stdlib.h>
  27 #include <unistd.h>
  28 #include <sys/param.h>
  29 #include <sys/stat.h>
  30
  31 #include "localedef.h"
  32 #include "locfile.h"
  33
  34 #include "locfile-kw.h"
  35
  36
  37 int
  38 locfile_read (struct localedef_t *result, struct charmap_t *charmap)
  39 {
  40   const char *filename = result->name;
  41   const char *repertoire_name = result->repertoire_name;
  42   int locale_mask = result->needed ^ result->avail;
  43   struct linereader *ldfile;
  44   int not_here = ALL_LOCALES;
  45
  46   /* If no repertoire name was specified use the global one.  */
  47   if (repertoire_name == NULL)
  48     repertoire_name = repertoire_global;
  49
  50   /* Open the locale definition file.  */
  51   ldfile = lr_open (filename, locfile_hash);
  52   if (ldfile == NULL)
  53     {
  54       if (filename[0] != '/')
  55         {
  56           char *i18npath = getenv ("I18NPATH");
  57           if (i18npath != NULL && *i18npath != '\0')
  58             {
  59               char path[strlen (filename) + 1 + strlen (i18npath)
  60                         + sizeof ("/locales/") - 1];
  61               char *next;
  62               i18npath = strdupa (i18npath);
  63
  64
  65               while (ldfile == NULL
  66                      && (next = strsep (&i18npath, ":")) != NULL)
  67                 {
  68                   stpcpy (stpcpy (stpcpy (path, next), "/locales/"), filename);
  69
  70                   ldfile = lr_open (path, locfile_hash);
  71
  72                   if (ldfile == NULL)
  73                     {
  74                       stpcpy (stpcpy (path, next), filename);
  75
  76                       ldfile = lr_open (path, locfile_hash);
  77                     }
  78                 }
  79             }
  80
  81           /* Test in the default directory.  */
  82           if (ldfile == NULL)
  83             {
  84               char path[strlen (filename) + 1 + sizeof (LOCSRCDIR)];
  85
  86               stpcpy (stpcpy (stpcpy (path, LOCSRCDIR), "/"), filename);
  87               ldfile = lr_open (path, locfile_hash);
  88             }
  89         }
  90
  91       if (ldfile == NULL)
  92         return 1;
  93     }
  94
  95     /* Parse locale definition file and store result in RESULT.  */
  96   while (1)
  97     {
  98       struct token *now = lr_token (ldfile, charmap, NULL, verbose);
  99       enum token_t nowtok = now->tok;
 100       struct token *arg;
 101
 102       if (nowtok == tok_eof)
 103         break;
 104
 105       if (nowtok == tok_eol)
 106         /* Ignore empty lines.  */
 107         continue;
 108
 109       switch (nowtok)
 110         {
 111         case tok_escape_char:
 112         case tok_comment_char:
 113           /* We need an argument.  */
 114           arg = lr_token (ldfile, charmap, NULL, verbose);
 115
 116           if (arg->tok != tok_ident)
 117             {
 118               SYNTAX_ERROR (_("bad argument"));
 119               continue;
 120             }
 121
 122           if (arg->val.str.lenmb != 1)
 123             {
 124               lr_error (ldfile, _("\
 125 argument to `%s' must be a single character"),
 126                         nowtok == tok_escape_char
 127                         ? "escape_char" : "comment_char");
 128
 129               lr_ignore_rest (ldfile, 0);
 130               continue;
 131             }
 132
 133           if (nowtok == tok_escape_char)
 134             ldfile->escape_char = *arg->val.str.startmb;
 135           else
 136             ldfile->comment_char = *arg->val.str.startmb;
 137           break;
 138
 139         case tok_repertoiremap:
 140           /* We need an argument.  */
 141           arg = lr_token (ldfile, charmap, NULL, verbose);
 142
 143           if (arg->tok != tok_ident)
 144             {
 145               SYNTAX_ERROR (_("bad argument"));
 146               continue;
 147             }
 148
 149           if (repertoire_name == NULL)
 150             {
 151               repertoire_name = memcpy (xmalloc (arg->val.str.lenmb + 1),
 152                                         arg->val.str.startmb,
 153                                         arg->val.str.lenmb);
 154               ((char *) repertoire_name)[arg->val.str.lenmb] = '\0';
 155             }
 156           break;
 157
 158         case tok_lc_ctype:
 159           ctype_read (ldfile, result, charmap, repertoire_name,
 160                       (locale_mask & CTYPE_LOCALE) == 0);
 161           result->avail |= locale_mask & CTYPE_LOCALE;
 162           not_here ^= CTYPE_LOCALE;
 163           continue;
 164
 165         case tok_lc_collate:
 166           collate_read (ldfile, result, charmap, repertoire_name,
 167                         (locale_mask & COLLATE_LOCALE) == 0);
 168           result->avail |= locale_mask & COLLATE_LOCALE;
 169           not_here ^= COLLATE_LOCALE;
 170           continue;
 171
 172         case tok_lc_monetary:
 173           monetary_read (ldfile, result, charmap, repertoire_name,
 174                          (locale_mask & MONETARY_LOCALE) == 0);
 175           result->avail |= locale_mask & MONETARY_LOCALE;
 176           not_here ^= MONETARY_LOCALE;
 177           continue;
 178
 179         case tok_lc_numeric:
 180           numeric_read (ldfile, result, charmap, repertoire_name,
 181                         (locale_mask & NUMERIC_LOCALE) == 0);
 182           result->avail |= locale_mask & NUMERIC_LOCALE;
 183           not_here ^= NUMERIC_LOCALE;
 184           continue;
 185
 186         case tok_lc_time:
 187           time_read (ldfile, result, charmap, repertoire_name,
 188                      (locale_mask & TIME_LOCALE) == 0);
 189           result->avail |= locale_mask & TIME_LOCALE;
 190           not_here ^= TIME_LOCALE;
 191           continue;
 192
 193         case tok_lc_messages:
 194           messages_read (ldfile, result, charmap, repertoire_name,
 195                          (locale_mask & MESSAGES_LOCALE) == 0);
 196           result->avail |= locale_mask & MESSAGES_LOCALE;
 197           not_here ^= MESSAGES_LOCALE;
 198           continue;
 199
 200         case tok_lc_paper:
 201           paper_read (ldfile, result, charmap, repertoire_name,
 202                       (locale_mask & PAPER_LOCALE) == 0);
 203           result->avail |= locale_mask & PAPER_LOCALE;
 204           not_here ^= PAPER_LOCALE;
 205           continue;
 206
 207         case tok_lc_name:
 208           name_read (ldfile, result, charmap, repertoire_name,
 209                      (locale_mask & NAME_LOCALE) == 0);
 210           result->avail |= locale_mask & NAME_LOCALE;
 211           not_here ^= NAME_LOCALE;
 212           continue;
 213
 214         case tok_lc_address:
 215           address_read (ldfile, result, charmap, repertoire_name,
 216                         (locale_mask & ADDRESS_LOCALE) == 0);
 217           result->avail |= locale_mask & ADDRESS_LOCALE;
 218           not_here ^= ADDRESS_LOCALE;
 219           continue;
 220
 221         case tok_lc_telephone:
 222           telephone_read (ldfile, result, charmap, repertoire_name,
 223                           (locale_mask & TELEPHONE_LOCALE) == 0);
 224           result->avail |= locale_mask & TELEPHONE_LOCALE;
 225           not_here ^= TELEPHONE_LOCALE;
 226           continue;
 227
 228         case tok_lc_measurement:
 229           measurement_read (ldfile, result, charmap, repertoire_name,
 230                             (locale_mask & MEASUREMENT_LOCALE) == 0);
 231           result->avail |= locale_mask & MEASUREMENT_LOCALE;
 232           not_here ^= MEASUREMENT_LOCALE;
 233           continue;
 234
 235         case tok_lc_identification:
 236           identification_read (ldfile, result, charmap, repertoire_name,
 237                                (locale_mask & IDENTIFICATION_LOCALE) == 0);
 238           result->avail |= locale_mask & IDENTIFICATION_LOCALE;
 239           not_here ^= IDENTIFICATION_LOCALE;
 240           continue;
 241
 242         default:
 243           SYNTAX_ERROR (_("\
 244 syntax error: not inside a locale definition section"));
 245           continue;
 246         }
 247
 248       /* The rest of the line must be empty.  */
 249       lr_ignore_rest (ldfile, 1);
 250     }
 251
 252   /* We read all of the file.  */
 253   lr_close (ldfile);
 254
 255   /* Mark the categories which are not contained in the file.  We assume
 256      them to be available and the default data will be used.  */
 257   result->avail |= not_here;
 258
 259   return 0;
 260 }
 261
 262
 263 static void (*const check_funcs[]) (struct localedef_t *,
 264                                     struct charmap_t *) =
 265 {
 266   [LC_CTYPE] = ctype_finish,
 267   [LC_COLLATE] = collate_finish,
 268   [LC_MESSAGES] = messages_finish,
 269   [LC_MONETARY] = monetary_finish,
 270   [LC_NUMERIC] = numeric_finish,
 271   [LC_TIME] = time_finish,
 272   [LC_PAPER] = paper_finish,
 273   [LC_NAME] = name_finish,
 274   [LC_ADDRESS] = address_finish,
 275   [LC_TELEPHONE] = telephone_finish,
 276   [LC_MEASUREMENT] = measurement_finish,
 277   [LC_IDENTIFICATION] = identification_finish
 278 };
 279
 280
 281 void
 282 check_all_categories (struct localedef_t *definitions,
 283                       struct charmap_t *charmap)
 284 {
 285   int cnt;
 286
 287   for (cnt = 0; cnt < sizeof (check_funcs) / sizeof (check_funcs[0]); ++cnt)
 288     if (check_funcs[cnt] != NULL)
 289       check_funcs[cnt] (definitions, charmap);
 290 }
 291
 292
 293 static void (*const write_funcs[]) (struct localedef_t *, struct charmap_t *,
 294                                     const char *) =
 295 {
 296   [LC_CTYPE] = ctype_output,
 297   [LC_COLLATE] = collate_output,
 298   [LC_MESSAGES] = messages_output,
 299   [LC_MONETARY] = monetary_output,
 300   [LC_NUMERIC] = numeric_output,
 301   [LC_TIME] = time_output,
 302   [LC_PAPER] = paper_output,
 303   [LC_NAME] = name_output,
 304   [LC_ADDRESS] = address_output,
 305   [LC_TELEPHONE] = telephone_output,
 306   [LC_MEASUREMENT] = measurement_output,
 307   [LC_IDENTIFICATION] = identification_output
 308 };
 309
 310
 311 void
 312 write_all_categories (struct localedef_t *definitions,
 313                       struct charmap_t *charmap,
 314                       const char *output_path)
 315 {
 316   int cnt;
 317
 318   for (cnt = 0; cnt < sizeof (write_funcs) / sizeof (write_funcs[0]); ++cnt)
 319     if (write_funcs[cnt] != NULL)
 320       write_funcs[cnt] (definitions, charmap, output_path);
 321 }
 322
 323
 324 void
 325 write_locale_data (const char *output_path, const char *category,
 326                    size_t n_elem, struct iovec *vec)
 327 {
 328   size_t cnt, step, maxiov;
 329   int fd;
 330   char *fname;
 331
 332   fname = malloc (strlen (output_path) + 2 * strlen (category) + 7);
 333   if (fname == NULL)
 334     error (5, errno, _("memory exhausted"));
 335
 336   /* Normally we write to the directory pointed to by the OUTPUT_PATH.
 337      But for LC_MESSAGES we have to take care for the translation
 338      data.  This means we need to have a directory LC_MESSAGES in
 339      which we place the file under the name SYS_LC_MESSAGES.  */
 340   sprintf (fname, "%s%s", output_path, category);
 341   if (strcmp (category, "LC_MESSAGES") == 0)
 342     {
 343       struct stat st;
 344
 345       if (stat (fname, &st) < 0)
 346         {
 347           if (mkdir (fname, 0777) < 0)
 348             fd = creat (fname, 0666);
 349           else
 350             {
 351               fd = -1;
 352               errno = EISDIR;
 353             }
 354         }
 355       else if (S_ISREG (st.st_mode))
 356         fd = creat (fname, 0666);
 357       else
 358         {
 359           fd = -1;
 360           errno = EISDIR;
 361         }
 362     }
 363   else
 364     fd = creat (fname, 0666);
 365
 366   if (fd == -1)
 367     {
 368       int save_err = errno;
 369
 370       if (errno == EISDIR)
 371         {
 372           sprintf (fname, "%1$s/%2$s/SYS_%2$s", output_path, category);
 373           fd = creat (fname, 0666);
 374           if (fd == -1)
 375             save_err = errno;
 376         }
 377
 378       if (fd == -1)
 379         {
 380           if (!be_quiet)
 381             error (0, save_err, _("\
 382 cannot open output file `%s' for category `%s'"),
 383                    fname, category);
 384           return;
 385         }
 386     }
 387   free (fname);
 388
 389 #ifdef UIO_MAXIOV
 390   maxiov = UIO_MAXIOV;
 391 #else
 392   maxiov = sysconf (_SC_UIO_MAXIOV);
 393 #endif
 394
 395   /* Write the data using writev.  But we must take care for the
 396      limitation of the implementation.  */
 397   for (cnt = 0; cnt < n_elem; cnt += step)
 398     {
 399       step = n_elem - cnt;
 400       if (maxiov > 0)
 401         step = MIN (maxiov, step);
 402
 403       if (writev (fd, &vec[cnt], step) < 0)
 404         {
 405           if (!be_quiet)
 406             error (0, errno, _("failure while writing data for category `%s'"),
 407                    category);
 408           break;
 409         }
 410     }
 411
 412   close (fd);
 413 }