[Feature][ZXW-33]merge ZXW 0428 version
Change-Id: I11f167edfea428d9fab198ff00ff1364932d1b0b
diff --git a/ap/libc/glibc/glibc-2.23/locale/programs/repertoire.c b/ap/libc/glibc/glibc-2.23/locale/programs/repertoire.c
new file mode 100644
index 0000000..c398707
--- /dev/null
+++ b/ap/libc/glibc/glibc-2.23/locale/programs/repertoire.c
@@ -0,0 +1,524 @@
+/* Copyright (C) 1998-2016 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;
+}