Back to index

glibc  2.9
Defines | Functions | Variables
repertoire.c File Reference
#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 "localedef.h"
#include "linereader.h"
#include "charmap.h"
#include "repertoire.h"
#include "simple-hash.h"

Go to the source code of this file.

Defines

#define obstack_chunk_alloc   malloc
#define obstack_chunk_free   free

Functions

static struct keyword_trepertoiremap_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)
struct repertoire_trepertoire_read (const char *filename)
void repertoire_complain (const char *name)
uint32_t repertoire_find_value (const struct repertoire_t *rep, const char *name, size_t len)
const char * repertoire_find_symbol (const struct repertoire_t *rep, uint32_t ucs)
struct charseqrepertoire_find_seq (const struct repertoire_t *rep, uint32_t ucs)

Variables

static void * known
static void * unavailable

Define Documentation

#define obstack_chunk_free   free

Function Documentation

static int repertoire_compare ( const void *  p1,
const void *  p2 
) [static]

Definition at line 352 of file repertoire.c.

{
  struct repertoire_t *r1 = (struct repertoire_t *) p1;
  struct repertoire_t *r2 = (struct repertoire_t *) p2;

  return strcmp (r1->name, r2->name);
}

Here is the caller graph for this function:

void repertoire_complain ( const char *  name)

Definition at line 338 of file repertoire.c.

{
  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);
    }
}

Here is the call graph for this function:

struct charseq* repertoire_find_seq ( const struct repertoire_t rep,
uint32_t  ucs 
) [read]

Definition at line 512 of file repertoire.c.

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const char* repertoire_find_symbol ( const struct repertoire_t rep,
uint32_t  ucs 
)

Definition at line 496 of file repertoire.c.

{
  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;
}

Here is the call graph for this function:

uint32_t repertoire_find_value ( const struct repertoire_t rep,
const char *  name,
size_t  len 
)

Definition at line 480 of file repertoire.c.

{
  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);
}

Here is the call graph for this function:

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]

Definition at line 386 of file repertoire.c.

{
  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);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct repertoire_t* repertoire_read ( const char *  filename) [read]

Definition at line 57 of file repertoire.c.

{
  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 (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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct keyword_t * repertoiremap_hash ( const char *  str,
unsigned int  len 
) [static, read]

Definition at line 362 of file repertoire.c.

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

void* known [static]

Definition at line 49 of file repertoire.c.

void* unavailable [static]

Definition at line 53 of file repertoire.c.