/* Copyright (C) 1998-2018 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 <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)

    record_error (0, 0, _("%s: premature end of file"),

		  repfile->fname);

  lr_close (repfile);

  if (tsearch (result, &known, &repertoire_compare) == NULL)

    /* Something went wrong.  */

    record_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)

    {

      record_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;

}