glibc/locale/programs/repertoire.c

525 lines
13 KiB
C

/* Copyright (C) 1998-2017 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
by the Free Software Foundation; version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, see <http://www.gnu.org/licenses/>. */
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <errno.h>
#include <error.h>
#include <limits.h>
#include <obstack.h>
#include <search.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stdint.h>
#include "localedef.h"
#include "linereader.h"
#include "charmap.h"
#include "repertoire.h"
#include "simple-hash.h"
/* Simple keyword hashing for the repertoiremap. */
static const struct keyword_t *repertoiremap_hash (const char *str,
unsigned int len);
static void repertoire_new_char (struct linereader *lr, hash_table *ht,
hash_table *rt, struct obstack *ob,
uint32_t value, const char *from,
const char *to, int decimal_ellipsis);
static int repertoire_compare (const void *p1, const void *p2);
/* Already known repertoire maps. */
static void *known;
/* List of repertoire maps which are not available and which have been
reported to not be. */
static void *unavailable;
struct repertoire_t *
repertoire_read (const char *filename)
{
struct linereader *repfile;
struct repertoire_t *result;
struct repertoire_t **resultp;
struct repertoire_t search;
int state;
char *from_name = NULL;
char *to_name = NULL;
enum token_t ellipsis = tok_none;
search.name = filename;
resultp = tfind (&search, &known, &repertoire_compare);
if (resultp != NULL)
return *resultp;
/* Determine path. */
repfile = lr_open (filename, repertoiremap_hash);
if (repfile == NULL)
{
if (strchr (filename, '/') == NULL)
{
char *i18npath = getenv ("I18NPATH");
if (i18npath != NULL && *i18npath != '\0')
{
const size_t pathlen = strlen (i18npath);
char i18npathbuf[pathlen + 1];
char path[strlen (filename) + 1 + pathlen
+ sizeof ("/repertoiremaps/") - 1];
char *next;
i18npath = memcpy (i18npathbuf, i18npath, pathlen + 1);
while (repfile == NULL
&& (next = strsep (&i18npath, ":")) != NULL)
{
stpcpy (stpcpy (stpcpy (path, next), "/repertoiremaps/"),
filename);
repfile = lr_open (path, repertoiremap_hash);
if (repfile == NULL)
{
stpcpy (stpcpy (stpcpy (path, next), "/"), filename);
repfile = lr_open (path, repertoiremap_hash);
}
}
}
if (repfile == NULL)
{
/* Look in the systems charmap directory. */
char *buf = xmalloc (strlen (filename) + 1
+ sizeof (REPERTOIREMAP_PATH));
stpcpy (stpcpy (stpcpy (buf, REPERTOIREMAP_PATH), "/"),
filename);
repfile = lr_open (buf, repertoiremap_hash);
free (buf);
}
}
if (repfile == NULL)
return NULL;
}
/* We don't want symbolic names in string to be translated. */
repfile->translate_strings = 0;
/* Allocate room for result. */
result = (struct repertoire_t *) xmalloc (sizeof (struct repertoire_t));
memset (result, '\0', sizeof (struct repertoire_t));
result->name = xstrdup (filename);
#define obstack_chunk_alloc malloc
#define obstack_chunk_free free
obstack_init (&result->mem_pool);
if (init_hash (&result->char_table, 256)
|| init_hash (&result->reverse_table, 256)
|| init_hash (&result->seq_table, 256))
{
free (result);
return NULL;
}
/* We use a state machine to describe the charmap description file
format. */
state = 1;
while (1)
{
/* What's on? */
struct token *now = lr_token (repfile, NULL, NULL, NULL, verbose);
enum token_t nowtok = now->tok;
struct token *arg;
if (nowtok == tok_eof)
break;
switch (state)
{
case 1:
/* We haven't yet read any character definition. This is where
we accept escape_char and comment_char definitions. */
if (nowtok == tok_eol)
/* Ignore empty lines. */
continue;
if (nowtok == tok_escape_char || nowtok == tok_comment_char)
{
/* We know that we need an argument. */
arg = lr_token (repfile, NULL, NULL, NULL, verbose);
if (arg->tok != tok_ident)
{
lr_error (repfile, _("syntax error in prolog: %s"),
_("bad argument"));
lr_ignore_rest (repfile, 0);
continue;
}
if (arg->val.str.lenmb != 1)
{
lr_error (repfile, _("\
argument to <%s> must be a single character"),
nowtok == tok_escape_char ? "escape_char"
: "comment_char");
lr_ignore_rest (repfile, 0);
continue;
}
if (nowtok == tok_escape_char)
repfile->escape_char = *arg->val.str.startmb;
else
repfile->comment_char = *arg->val.str.startmb;
lr_ignore_rest (repfile, 1);
continue;
}
if (nowtok == tok_charids)
{
lr_ignore_rest (repfile, 1);
state = 2;
continue;
}
/* Otherwise we start reading the character definitions. */
state = 2;
/* FALLTHROUGH */
case 2:
/* We are now are in the body. Each line
must have the format "%s %s %s\n" or "%s...%s %s %s\n". */
if (nowtok == tok_eol)
/* Ignore empty lines. */
continue;
if (nowtok == tok_end)
{
state = 90;
continue;
}
if (nowtok != tok_bsymbol)
{
lr_error (repfile,
_("syntax error in repertoire map definition: %s"),
_("no symbolic name given"));
lr_ignore_rest (repfile, 0);
continue;
}
/* If the previous line was not completely correct free the
used memory. */
if (from_name != NULL)
obstack_free (&result->mem_pool, from_name);
from_name = (char *) obstack_copy0 (&result->mem_pool,
now->val.str.startmb,
now->val.str.lenmb);
to_name = NULL;
state = 3;
continue;
case 3:
/* We have two possibilities: We can see an ellipsis or an
encoding value. */
if (nowtok == tok_ellipsis3 || nowtok == tok_ellipsis4
|| nowtok == tok_ellipsis2)
{
ellipsis = nowtok;
state = 4;
continue;
}
/* FALLTHROUGH */
case 5:
/* We expect a value of the form <Uxxxx> or <Uxxxxxxxx> where
the xxx mean a hexadecimal value. */
state = 2;
errno = 0;
if (nowtok != tok_ucs4)
{
lr_error (repfile,
_("syntax error in repertoire map definition: %s"),
_("no <Uxxxx> or <Uxxxxxxxx> value given"));
lr_ignore_rest (repfile, 0);
continue;
}
/* We've found a new valid definition. */
repertoire_new_char (repfile, &result->char_table,
&result->reverse_table, &result->mem_pool,
now->val.ucs4, from_name, to_name,
ellipsis != tok_ellipsis2);
/* Ignore the rest of the line. */
lr_ignore_rest (repfile, 0);
from_name = NULL;
to_name = NULL;
continue;
case 4:
if (nowtok != tok_bsymbol)
{
lr_error (repfile,
_("syntax error in repertoire map definition: %s"),
_("no symbolic name given for end of range"));
lr_ignore_rest (repfile, 0);
state = 2;
continue;
}
/* Copy the to-name in a safe place. */
to_name = (char *) obstack_copy0 (&result->mem_pool,
repfile->token.val.str.startmb,
repfile->token.val.str.lenmb);
state = 5;
continue;
case 90:
if (nowtok != tok_charids)
lr_error (repfile, _("\
%1$s: definition does not end with `END %1$s'"), "CHARIDS");
lr_ignore_rest (repfile, nowtok == tok_charids);
break;
}
break;
}
if (state != 2 && state != 90 && !be_quiet)
WITH_CUR_LOCALE (error (0, 0, _("%s: premature end of file"),
repfile->fname));
lr_close (repfile);
if (tsearch (result, &known, &repertoire_compare) == NULL)
/* Something went wrong. */
WITH_CUR_LOCALE (error (0, errno, _("cannot save new repertoire map")));
return result;
}
void
repertoire_complain (const char *name)
{
if (tfind (name, &unavailable, (__compar_fn_t) strcmp) == NULL)
{
WITH_CUR_LOCALE (error (0, errno, _("\
repertoire map file `%s' not found"), name));
/* Remember that we reported this map. */
tsearch (name, &unavailable, (__compar_fn_t) strcmp);
}
}
static int
repertoire_compare (const void *p1, const void *p2)
{
struct repertoire_t *r1 = (struct repertoire_t *) p1;
struct repertoire_t *r2 = (struct repertoire_t *) p2;
return strcmp (r1->name, r2->name);
}
static const struct keyword_t *
repertoiremap_hash (const char *str, unsigned int len)
{
static const struct keyword_t wordlist[] =
{
{"escape_char", tok_escape_char, 0},
{"comment_char", tok_comment_char, 0},
{"CHARIDS", tok_charids, 0},
{"END", tok_end, 0},
};
if (len == 11 && memcmp (wordlist[0].name, str, 11) == 0)
return &wordlist[0];
if (len == 12 && memcmp (wordlist[1].name, str, 12) == 0)
return &wordlist[1];
if (len == 7 && memcmp (wordlist[2].name, str, 7) == 0)
return &wordlist[2];
if (len == 3 && memcmp (wordlist[3].name, str, 3) == 0)
return &wordlist[3];
return NULL;
}
static void
repertoire_new_char (struct linereader *lr, hash_table *ht, hash_table *rt,
struct obstack *ob, uint32_t value, const char *from,
const char *to, int decimal_ellipsis)
{
char *from_end;
char *to_end;
const char *cp;
char *buf = NULL;
int prefix_len, len1, len2;
unsigned long int from_nr, to_nr, cnt;
if (to == NULL)
{
insert_entry (ht, from, strlen (from),
(void *) (unsigned long int) value);
/* Please note that it isn't a bug if a symbol is defined more
than once. All later definitions are simply discarded. */
insert_entry (rt, obstack_copy (ob, &value, sizeof (value)),
sizeof (value), (void *) from);
return;
}
/* We have a range: the names must have names with equal prefixes
and an equal number of digits, where the second number is greater
or equal than the first. */
len1 = strlen (from);
len2 = strlen (to);
if (len1 != len2)
{
invalid_range:
lr_error (lr, _("invalid names for character range"));
return;
}
cp = &from[len1 - 1];
if (decimal_ellipsis)
while (isdigit (*cp) && cp >= from)
--cp;
else
while (isxdigit (*cp) && cp >= from)
{
if (!isdigit (*cp) && !isupper (*cp))
lr_error (lr, _("\
hexadecimal range format should use only capital characters"));
--cp;
}
prefix_len = (cp - from) + 1;
if (cp == &from[len1 - 1] || strncmp (from, to, prefix_len) != 0)
goto invalid_range;
errno = 0;
from_nr = strtoul (&from[prefix_len], &from_end, decimal_ellipsis ? 10 : 16);
if (*from_end != '\0' || (from_nr == ULONG_MAX && errno == ERANGE)
|| ((to_nr = strtoul (&to[prefix_len], &to_end,
decimal_ellipsis ? 10 : 16)) == ULONG_MAX
&& errno == ERANGE)
|| *to_end != '\0')
{
lr_error (lr, _("<%s> and <%s> are invalid names for range"),
from, to);
return;
}
if (from_nr > to_nr)
{
lr_error (lr, _("upper limit in range is smaller than lower limit"));
return;
}
for (cnt = from_nr; cnt <= to_nr; ++cnt)
{
uint32_t this_value = value + (cnt - from_nr);
obstack_printf (ob, decimal_ellipsis ? "%.*s%0*ld" : "%.*s%0*lX",
prefix_len, from, len1 - prefix_len, cnt);
obstack_1grow (ob, '\0');
insert_entry (ht, buf, len1,
(void *) (unsigned long int) this_value);
/* Please note we don't examine the return value since it is no error
if we have two definitions for a symbol. */
insert_entry (rt, obstack_copy (ob, &this_value, sizeof (this_value)),
sizeof (this_value), (void *) from);
}
}
uint32_t
repertoire_find_value (const struct repertoire_t *rep, const char *name,
size_t len)
{
void *result;
if (rep == NULL)
return ILLEGAL_CHAR_VALUE;
if (find_entry ((hash_table *) &rep->char_table, name, len, &result) < 0)
return ILLEGAL_CHAR_VALUE;
return (uint32_t) ((unsigned long int) result);
}
const char *
repertoire_find_symbol (const struct repertoire_t *rep, uint32_t ucs)
{
void *result;
if (rep == NULL)
return NULL;
if (find_entry ((hash_table *) &rep->reverse_table, &ucs, sizeof (ucs),
&result) < 0)
return NULL;
return (const char *) result;
}
struct charseq *
repertoire_find_seq (const struct repertoire_t *rep, uint32_t ucs)
{
void *result;
if (rep == NULL)
return NULL;
if (find_entry ((hash_table *) &rep->seq_table, &ucs, sizeof (ucs),
&result) < 0)
return NULL;
return (struct charseq *) result;
}