locale/programs/repertoire.c

   1 /* Copyright (C) 1998,1999,2000,2001,2002,2004 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the 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    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 # include <config.h>
  22 #endif
  23
  24 #include <errno.h>
  25 #include <error.h>
  26 #include <limits.h>
  27 #include <obstack.h>
  28 #include <search.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <unistd.h>
  32
  33 #include "localedef.h"
  34 #include "linereader.h"
  35 #include "charmap.h"
  36 #include "repertoire.h"
  37 #include "simple-hash.h"
  38
  39
  40 /* Simple keyword hashing for the repertoiremap.  */
  41 static const struct keyword_t *repertoiremap_hash (const char *str,
  42                                                    unsigned int len);
  43 static void repertoire_new_char (struct linereader *lr, hash_table *ht,
  44                                  hash_table *rt, struct obstack *ob,
  45                                  uint32_t value, const char *from,
  46                                  const char *to, int decimal_ellipsis);
  47 static int repertoire_compare (const void *p1, const void *p2);
  48
  49 /* Already known repertoire maps.  */
  50 static void *known;
  51
  52 /* List of repertoire maps which are not available and which have been
  53    reported to not be.  */
  54 static void *unavailable;
  55
  56
  57 struct repertoire_t *
  58 repertoire_read (const char *filename)
  59 {
  60   struct linereader *repfile;
  61   struct repertoire_t *result;
  62   struct repertoire_t **resultp;
  63   struct repertoire_t search;
  64   int state;
  65   char *from_name = NULL;
  66   char *to_name = NULL;
  67   enum token_t ellipsis = tok_none;
  68
  69   search.name = filename;
  70   resultp = tfind (&search, &known, &repertoire_compare);
  71   if (resultp != NULL)
  72     return *resultp;
  73
  74   /* Determine path.  */
  75   repfile = lr_open (filename, repertoiremap_hash);
  76   if (repfile == NULL)
  77     {
  78       if (strchr (filename, '/') == NULL)
  79         {
  80           char *i18npath = getenv ("I18NPATH");
  81           if (i18npath != NULL && *i18npath != '\0')
  82             {
  83               const size_t pathlen = strlen (i18npath);
  84               char i18npathbuf[pathlen + 1];
  85               char path[strlen (filename) + 1 + pathlen
  86                         + sizeof ("/repertoiremaps/") - 1];
  87               char *next;
  88               i18npath = memcpy (i18npathbuf, i18npath, pathlen + 1);
  89
  90               while (repfile == NULL
  91                      && (next = strsep (&i18npath, ":")) != NULL)
  92                 {
  93                   stpcpy (stpcpy (stpcpy (path, next), "/repertoiremaps/"),
  94                           filename);
  95
  96                   repfile = lr_open (path, repertoiremap_hash);
  97
  98                   if (repfile == NULL)
  99                     {
 100                       stpcpy (stpcpy (path, next), filename);
 101
 102                       repfile = lr_open (path, repertoiremap_hash);
 103                     }
 104                 }
 105             }
 106
 107           if (repfile == NULL)
 108             {
 109               /* Look in the systems charmap directory.  */
 110               char *buf = xmalloc (strlen (filename) + 1
 111                                    + sizeof (REPERTOIREMAP_PATH));
 112
 113               stpcpy (stpcpy (stpcpy (buf, REPERTOIREMAP_PATH), "/"),
 114                       filename);
 115               repfile = lr_open (buf, repertoiremap_hash);
 116
 117               if (repfile == NULL)
 118                 free (buf);
 119             }
 120         }
 121
 122       if (repfile == NULL)
 123         return NULL;
 124     }
 125
 126   /* We don't want symbolic names in string to be translated.  */
 127   repfile->translate_strings = 0;
 128
 129   /* Allocate room for result.  */
 130   result = (struct repertoire_t *) xmalloc (sizeof (struct repertoire_t));
 131   memset (result, '\0', sizeof (struct repertoire_t));
 132
 133   result->name = xstrdup (filename);
 134
 135 #define obstack_chunk_alloc malloc
 136 #define obstack_chunk_free free
 137   obstack_init (&result->mem_pool);
 138
 139   if (init_hash (&result->char_table, 256)
 140       || init_hash (&result->reverse_table, 256)
 141       || init_hash (&result->seq_table, 256))
 142     {
 143       free (result);
 144       return NULL;
 145     }
 146
 147   /* We use a state machine to describe the charmap description file
 148      format.  */
 149   state = 1;
 150   while (1)
 151     {
 152       /* What's on?  */
 153       struct token *now = lr_token (repfile, NULL, NULL, NULL, verbose);
 154       enum token_t nowtok = now->tok;
 155       struct token *arg;
 156
 157       if (nowtok == tok_eof)
 158         break;
 159
 160       switch (state)
 161         {
 162         case 1:
 163           /* We haven't yet read any character definition.  This is where
 164              we accept escape_char and comment_char definitions.  */
 165           if (nowtok == tok_eol)
 166             /* Ignore empty lines.  */
 167             continue;
 168
 169           if (nowtok == tok_escape_char || nowtok == tok_comment_char)
 170             {
 171               /* We know that we need an argument.  */
 172               arg = lr_token (repfile, NULL, NULL, NULL, verbose);
 173
 174               if (arg->tok != tok_ident)
 175                 {
 176                   lr_error (repfile, _("syntax error in prolog: %s"),
 177                             _("bad argument"));
 178
 179                   lr_ignore_rest (repfile, 0);
 180                   continue;
 181                 }
 182
 183               if (arg->val.str.lenmb != 1)
 184                 {
 185                   lr_error (repfile, _("\
 186 argument to <%s> must be a single character"),
 187                             nowtok == tok_escape_char ? "escape_char"
 188                                                       : "comment_char");
 189
 190                   lr_ignore_rest (repfile, 0);
 191                   continue;
 192                 }
 193
 194               if (nowtok == tok_escape_char)
 195                 repfile->escape_char = *arg->val.str.startmb;
 196               else
 197                 repfile->comment_char = *arg->val.str.startmb;
 198
 199               lr_ignore_rest (repfile, 1);
 200               continue;
 201             }
 202
 203           if (nowtok == tok_charids)
 204             {
 205               lr_ignore_rest (repfile, 1);
 206
 207               state = 2;
 208               continue;
 209             }
 210
 211           /* Otherwise we start reading the character definitions.  */
 212           state = 2;
 213           /* FALLTHROUGH */
 214
 215         case 2:
 216           /* We are now are in the body.  Each line
 217              must have the format "%s %s %s\n" or "%s...%s %s %s\n".  */
 218           if (nowtok == tok_eol)
 219             /* Ignore empty lines.  */
 220             continue;
 221
 222           if (nowtok == tok_end)
 223             {
 224               state = 90;
 225               continue;
 226             }
 227
 228           if (nowtok != tok_bsymbol)
 229             {
 230               lr_error (repfile,
 231                         _("syntax error in repertoire map definition: %s"),
 232                         _("no symbolic name given"));
 233
 234               lr_ignore_rest (repfile, 0);
 235               continue;
 236             }
 237
 238           /* If the previous line was not completely correct free the
 239              used memory.  */
 240           if (from_name != NULL)
 241             obstack_free (&result->mem_pool, from_name);
 242
 243           from_name = (char *) obstack_copy0 (&result->mem_pool,
 244                                               now->val.str.startmb,
 245                                               now->val.str.lenmb);
 246           to_name = NULL;
 247
 248           state = 3;
 249           continue;
 250
 251         case 3:
 252           /* We have two possibilities: We can see an ellipsis or an
 253              encoding value.  */
 254           if (nowtok == tok_ellipsis3 || nowtok == tok_ellipsis4
 255               || nowtok == tok_ellipsis2)
 256             {
 257               ellipsis = nowtok;
 258               state = 4;
 259               continue;
 260             }
 261           /* FALLTHROUGH */
 262
 263         case 5:
 264           /* We expect a value of the form <Uxxxx> or <Uxxxxxxxx> where
 265              the xxx mean a hexadecimal value.  */
 266           state = 2;
 267
 268           errno = 0;
 269           if (nowtok != tok_ucs4)
 270             {
 271               lr_error (repfile,
 272                         _("syntax error in repertoire map definition: %s"),
 273                         _("no <Uxxxx> or <Uxxxxxxxx> value given"));
 274
 275               lr_ignore_rest (repfile, 0);
 276               continue;
 277             }
 278
 279           /* We've found a new valid definition.  */
 280           repertoire_new_char (repfile, &result->char_table,
 281                                &result->reverse_table, &result->mem_pool,
 282                                now->val.ucs4, from_name, to_name,
 283                                ellipsis != tok_ellipsis2);
 284
 285           /* Ignore the rest of the line.  */
 286           lr_ignore_rest (repfile, 0);
 287
 288           from_name = NULL;
 289           to_name = NULL;
 290
 291           continue;
 292
 293         case 4:
 294           if (nowtok != tok_bsymbol)
 295             {
 296               lr_error (repfile,
 297                         _("syntax error in repertoire map definition: %s"),
 298                         _("no symbolic name given for end of range"));
 299
 300               lr_ignore_rest (repfile, 0);
 301               state = 2;
 302               continue;
 303             }
 304
 305           /* Copy the to-name in a safe place.  */
 306           to_name = (char *) obstack_copy0 (&result->mem_pool,
 307                                             repfile->token.val.str.startmb,
 308                                             repfile->token.val.str.lenmb);
 309
 310           state = 5;
 311           continue;
 312
 313         case 90:
 314           if (nowtok != tok_charids)
 315             lr_error (repfile, _("\
 316 `%1$s' definition does not end with `END %1$s'"), "CHARIDS");
 317
 318           lr_ignore_rest (repfile, nowtok == tok_charids);
 319           break;
 320         }
 321
 322       break;
 323     }
 324
 325   if (state != 2 && state != 90 && !be_quiet)
 326     WITH_CUR_LOCALE (error (0, 0, _("%s: premature end of file"),
 327                             repfile->fname));
 328
 329   lr_close (repfile);
 330
 331   if (tsearch (result, &known, &repertoire_compare) == NULL)
 332     /* Something went wrong.  */
 333     WITH_CUR_LOCALE (error (0, errno, _("cannot safe new repertoire map")));
 334
 335   return result;
 336 }
 337
 338
 339 void
 340 repertoire_complain (const char *name)
 341 {
 342   if (tfind (name, &unavailable, (__compar_fn_t) strcmp) == NULL)
 343     {
 344       WITH_CUR_LOCALE (error (0, errno, _("\
 345 repertoire map file `%s' not found"), name));
 346
 347       /* Remember that we reported this map.  */
 348       tsearch (name, &unavailable, (__compar_fn_t) strcmp);
 349     }
 350 }
 351
 352
 353 static int
 354 repertoire_compare (const void *p1, const void *p2)
 355 {
 356   struct repertoire_t *r1 = (struct repertoire_t *) p1;
 357   struct repertoire_t *r2 = (struct repertoire_t *) p2;
 358
 359   return strcmp (r1->name, r2->name);
 360 }
 361
 362
 363 static const struct keyword_t *
 364 repertoiremap_hash (const char *str, unsigned int len)
 365 {
 366   static const struct keyword_t wordlist[] =
 367   {
 368     {"escape_char",      tok_escape_char,     0},
 369     {"comment_char",     tok_comment_char,    0},
 370     {"CHARIDS",          tok_charids,         0},
 371     {"END",              tok_end,             0},
 372   };
 373
 374   if (len == 11 && memcmp (wordlist[0].name, str, 11) == 0)
 375     return &wordlist[0];
 376   if (len == 12 && memcmp (wordlist[1].name, str, 12) == 0)
 377     return &wordlist[1];
 378   if (len == 7 && memcmp (wordlist[2].name, str, 7) == 0)
 379     return &wordlist[2];
 380   if (len == 3 && memcmp (wordlist[3].name, str, 3) == 0)
 381     return &wordlist[3];
 382
 383   return NULL;
 384 }
 385
 386
 387 static void
 388 repertoire_new_char (struct linereader *lr, hash_table *ht, hash_table *rt,
 389                      struct obstack *ob, uint32_t value, const char *from,
 390                      const char *to, int decimal_ellipsis)
 391 {
 392   char *from_end;
 393   char *to_end;
 394   const char *cp;
 395   char *buf = NULL;
 396   int prefix_len, len1, len2;
 397   unsigned int from_nr, to_nr, cnt;
 398
 399   if (to == NULL)
 400     {
 401       insert_entry (ht, from, strlen (from),
 402                     (void *) (unsigned long int) value);
 403       /* Please note that it isn't a bug if a symbol is defined more
 404          than once.  All later definitions are simply discarded.  */
 405
 406       insert_entry (rt, obstack_copy (ob, &value, sizeof (value)),
 407                     sizeof (value), (void *) from);
 408
 409       return;
 410     }
 411
 412   /* We have a range: the names must have names with equal prefixes
 413      and an equal number of digits, where the second number is greater
 414      or equal than the first.  */
 415   len1 = strlen (from);
 416   len2 = strlen (to);
 417
 418   if (len1 != len2)
 419     {
 420     invalid_range:
 421       lr_error (lr, _("invalid names for character range"));
 422       return;
 423     }
 424
 425   cp = &from[len1 - 1];
 426   if (decimal_ellipsis)
 427     while (isdigit (*cp) && cp >= from)
 428       --cp;
 429   else
 430     while (isxdigit (*cp) && cp >= from)
 431       {
 432         if (!isdigit (*cp) && !isupper (*cp))
 433           lr_error (lr, _("\
 434 hexadecimal range format should use only capital characters"));
 435         --cp;
 436       }
 437
 438   prefix_len = (cp - from) + 1;
 439
 440   if (cp == &from[len1 - 1] || strncmp (from, to, prefix_len) != 0)
 441     goto invalid_range;
 442
 443   errno = 0;
 444   from_nr = strtoul (&from[prefix_len], &from_end, decimal_ellipsis ? 10 : 16);
 445   if (*from_end != '\0' || (from_nr == ULONG_MAX && errno == ERANGE)
 446       || ((to_nr = strtoul (&to[prefix_len], &to_end,
 447                             decimal_ellipsis ? 10 : 16)) == ULONG_MAX
 448           && errno == ERANGE)
 449       || *to_end != '\0')
 450     {
 451       lr_error (lr, _("<%s> and <%s> are invalid names for range"),
 452                 from, to);
 453       return;
 454     }
 455
 456   if (from_nr > to_nr)
 457     {
 458       lr_error (lr, _("upper limit in range is not smaller then lower limit"));
 459       return;
 460     }
 461
 462   for (cnt = from_nr; cnt <= to_nr; ++cnt)
 463     {
 464       uint32_t this_value = value + (cnt - from_nr);
 465
 466       obstack_printf (ob, decimal_ellipsis ? "%.*s%0*d" : "%.*s%0*X",
 467                       prefix_len, from, len1 - prefix_len, cnt);
 468       obstack_1grow (ob, '\0');
 469
 470       insert_entry (ht, buf, len1,
 471                     (void *) (unsigned long int) this_value);
 472       /* Please note we don't examine the return value since it is no error
 473          if we have two definitions for a symbol.  */
 474
 475       insert_entry (rt, obstack_copy (ob, &this_value, sizeof (this_value)),
 476                     sizeof (this_value), (void *) from);
 477     }
 478 }
 479
 480
 481 uint32_t
 482 repertoire_find_value (const struct repertoire_t *rep, const char *name,
 483                        size_t len)
 484 {
 485   void *result;
 486
 487   if (rep == NULL)
 488     return ILLEGAL_CHAR_VALUE;
 489
 490   if (find_entry ((hash_table *) &rep->char_table, name, len, &result) < 0)
 491     return ILLEGAL_CHAR_VALUE;
 492
 493   return (uint32_t) ((unsigned long int) result);
 494 }
 495
 496
 497 const char *
 498 repertoire_find_symbol (const struct repertoire_t *rep, uint32_t ucs)
 499 {
 500   void *result;
 501
 502   if (rep == NULL)
 503     return NULL;
 504
 505   if (find_entry ((hash_table *) &rep->reverse_table, &ucs, sizeof (ucs),
 506                   &result) < 0)
 507     return NULL;
 508
 509   return (const char *) result;
 510 }
 511
 512
 513 struct charseq *
 514 repertoire_find_seq (const struct repertoire_t *rep, uint32_t ucs)
 515 {
 516   void *result;
 517
 518   if (rep == NULL)
 519     return NULL;
 520
 521   if (find_entry ((hash_table *) &rep->seq_table, &ucs, sizeof (ucs),
 522                   &result) < 0)
 523     return NULL;
 524
 525   return (struct charseq *) result;
 526 }