OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [intl/] [dcigettext.c] - Diff between revs 816 and 818

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 816 Rev 818
/* Implementation of the internal dcigettext function.
/* Implementation of the internal dcigettext function.
   Copyright (C) 1995-1999, 2000-2003 Free Software Foundation, Inc.
   Copyright (C) 1995-1999, 2000-2003 Free Software Foundation, Inc.
 
 
   This program is free software; you can redistribute it and/or modify it
   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU Library General Public License as published
   under the terms of the GNU Library General Public License as published
   by the Free Software Foundation; either version 2, or (at your option)
   by the Free Software Foundation; either version 2, or (at your option)
   any later version.
   any later version.
 
 
   This program is distributed in the hope that it will be useful,
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
   Library General Public License for more details.
 
 
   You should have received a copy of the GNU Library General Public
   You should have received a copy of the GNU Library General Public
   License along with this program; if not, write to the Free Software
   License along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301,
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301,
   USA.  */
   USA.  */
 
 
/* Tell glibc's <string.h> to provide a prototype for mempcpy().
/* Tell glibc's <string.h> to provide a prototype for mempcpy().
   This must come before <config.h> because <config.h> may include
   This must come before <config.h> because <config.h> may include
   <features.h>, and once <features.h> has been included, it's too late.  */
   <features.h>, and once <features.h> has been included, it's too late.  */
#ifndef _GNU_SOURCE
#ifndef _GNU_SOURCE
# define _GNU_SOURCE    1
# define _GNU_SOURCE    1
#endif
#endif
 
 
#ifdef HAVE_CONFIG_H
#ifdef HAVE_CONFIG_H
# include <config.h>
# include <config.h>
#endif
#endif
 
 
#include <sys/types.h>
#include <sys/types.h>
 
 
#ifdef __GNUC__
#ifdef __GNUC__
# define alloca __builtin_alloca
# define alloca __builtin_alloca
# define HAVE_ALLOCA 1
# define HAVE_ALLOCA 1
#else
#else
# ifdef _MSC_VER
# ifdef _MSC_VER
#  include <malloc.h>
#  include <malloc.h>
#  define alloca _alloca
#  define alloca _alloca
# else
# else
#  if defined HAVE_ALLOCA_H || defined _LIBC
#  if defined HAVE_ALLOCA_H || defined _LIBC
#   include <alloca.h>
#   include <alloca.h>
#  else
#  else
#   ifdef _AIX
#   ifdef _AIX
 #pragma alloca
 #pragma alloca
#   else
#   else
#    ifndef alloca
#    ifndef alloca
char *alloca ();
char *alloca ();
#    endif
#    endif
#   endif
#   endif
#  endif
#  endif
# endif
# endif
#endif
#endif
 
 
#include <errno.h>
#include <errno.h>
#ifndef errno
#ifndef errno
extern int errno;
extern int errno;
#endif
#endif
#ifndef __set_errno
#ifndef __set_errno
# define __set_errno(val) errno = (val)
# define __set_errno(val) errno = (val)
#endif
#endif
 
 
#include <stddef.h>
#include <stddef.h>
#include <stdlib.h>
#include <stdlib.h>
#include <string.h>
#include <string.h>
 
 
#if defined HAVE_UNISTD_H || defined _LIBC
#if defined HAVE_UNISTD_H || defined _LIBC
# include <unistd.h>
# include <unistd.h>
#endif
#endif
 
 
#include <locale.h>
#include <locale.h>
 
 
#ifdef _LIBC
#ifdef _LIBC
  /* Guess whether integer division by zero raises signal SIGFPE.
  /* Guess whether integer division by zero raises signal SIGFPE.
     Set to 1 only if you know for sure.  In case of doubt, set to 0.  */
     Set to 1 only if you know for sure.  In case of doubt, set to 0.  */
# if defined __alpha__ || defined __arm__ || defined __i386__ \
# if defined __alpha__ || defined __arm__ || defined __i386__ \
     || defined __m68k__ || defined __s390__
     || defined __m68k__ || defined __s390__
#  define INTDIV0_RAISES_SIGFPE 1
#  define INTDIV0_RAISES_SIGFPE 1
# else
# else
#  define INTDIV0_RAISES_SIGFPE 0
#  define INTDIV0_RAISES_SIGFPE 0
# endif
# endif
#endif
#endif
#if !INTDIV0_RAISES_SIGFPE
#if !INTDIV0_RAISES_SIGFPE
# include <signal.h>
# include <signal.h>
#endif
#endif
 
 
#if defined HAVE_SYS_PARAM_H || defined _LIBC
#if defined HAVE_SYS_PARAM_H || defined _LIBC
# include <sys/param.h>
# include <sys/param.h>
#endif
#endif
 
 
#include "gettextP.h"
#include "gettextP.h"
#include "plural-exp.h"
#include "plural-exp.h"
#ifdef _LIBC
#ifdef _LIBC
# include <libintl.h>
# include <libintl.h>
#else
#else
# include "libgnuintl.h"
# include "libgnuintl.h"
#endif
#endif
#include "hash-string.h"
#include "hash-string.h"
 
 
/* Thread safetyness.  */
/* Thread safetyness.  */
#ifdef _LIBC
#ifdef _LIBC
# include <bits/libc-lock.h>
# include <bits/libc-lock.h>
#else
#else
/* Provide dummy implementation if this is outside glibc.  */
/* Provide dummy implementation if this is outside glibc.  */
# define __libc_lock_define_initialized(CLASS, NAME)
# define __libc_lock_define_initialized(CLASS, NAME)
# define __libc_lock_lock(NAME)
# define __libc_lock_lock(NAME)
# define __libc_lock_unlock(NAME)
# define __libc_lock_unlock(NAME)
# define __libc_rwlock_define_initialized(CLASS, NAME)
# define __libc_rwlock_define_initialized(CLASS, NAME)
# define __libc_rwlock_rdlock(NAME)
# define __libc_rwlock_rdlock(NAME)
# define __libc_rwlock_unlock(NAME)
# define __libc_rwlock_unlock(NAME)
#endif
#endif
 
 
/* Alignment of types.  */
/* Alignment of types.  */
#if defined __GNUC__ && __GNUC__ >= 2
#if defined __GNUC__ && __GNUC__ >= 2
# define alignof(TYPE) __alignof__ (TYPE)
# define alignof(TYPE) __alignof__ (TYPE)
#else
#else
# define alignof(TYPE) \
# define alignof(TYPE) \
    ((int) &((struct { char dummy1; TYPE dummy2; } *) 0)->dummy2)
    ((int) &((struct { char dummy1; TYPE dummy2; } *) 0)->dummy2)
#endif
#endif
 
 
/* The internal variables in the standalone libintl.a must have different
/* The internal variables in the standalone libintl.a must have different
   names than the internal variables in GNU libc, otherwise programs
   names than the internal variables in GNU libc, otherwise programs
   using libintl.a cannot be linked statically.  */
   using libintl.a cannot be linked statically.  */
#if !defined _LIBC
#if !defined _LIBC
# define _nl_default_default_domain libintl_nl_default_default_domain
# define _nl_default_default_domain libintl_nl_default_default_domain
# define _nl_current_default_domain libintl_nl_current_default_domain
# define _nl_current_default_domain libintl_nl_current_default_domain
# define _nl_default_dirname libintl_nl_default_dirname
# define _nl_default_dirname libintl_nl_default_dirname
# define _nl_domain_bindings libintl_nl_domain_bindings
# define _nl_domain_bindings libintl_nl_domain_bindings
#endif
#endif
 
 
/* Some compilers, like SunOS4 cc, don't have offsetof in <stddef.h>.  */
/* Some compilers, like SunOS4 cc, don't have offsetof in <stddef.h>.  */
#ifndef offsetof
#ifndef offsetof
# define offsetof(type,ident) ((size_t)&(((type*)0)->ident))
# define offsetof(type,ident) ((size_t)&(((type*)0)->ident))
#endif
#endif
 
 
/* @@ end of prolog @@ */
/* @@ end of prolog @@ */
 
 
#ifdef _LIBC
#ifdef _LIBC
/* Rename the non ANSI C functions.  This is required by the standard
/* Rename the non ANSI C functions.  This is required by the standard
   because some ANSI C functions will require linking with this object
   because some ANSI C functions will require linking with this object
   file and the name space must not be polluted.  */
   file and the name space must not be polluted.  */
# define getcwd __getcwd
# define getcwd __getcwd
# ifndef stpcpy
# ifndef stpcpy
#  define stpcpy __stpcpy
#  define stpcpy __stpcpy
# endif
# endif
# define tfind __tfind
# define tfind __tfind
#else
#else
# if !defined HAVE_GETCWD
# if !defined HAVE_GETCWD
char *getwd ();
char *getwd ();
#  define getcwd(buf, max) getwd (buf)
#  define getcwd(buf, max) getwd (buf)
# else
# else
char *getcwd ();
char *getcwd ();
# endif
# endif
# ifndef HAVE_STPCPY
# ifndef HAVE_STPCPY
static char *stpcpy PARAMS ((char *dest, const char *src));
static char *stpcpy PARAMS ((char *dest, const char *src));
# endif
# endif
# ifndef HAVE_MEMPCPY
# ifndef HAVE_MEMPCPY
static void *mempcpy PARAMS ((void *dest, const void *src, size_t n));
static void *mempcpy PARAMS ((void *dest, const void *src, size_t n));
# endif
# endif
#endif
#endif
 
 
/* Amount to increase buffer size by in each try.  */
/* Amount to increase buffer size by in each try.  */
#define PATH_INCR 32
#define PATH_INCR 32
 
 
/* The following is from pathmax.h.  */
/* The following is from pathmax.h.  */
/* Non-POSIX BSD systems might have gcc's limits.h, which doesn't define
/* Non-POSIX BSD systems might have gcc's limits.h, which doesn't define
   PATH_MAX but might cause redefinition warnings when sys/param.h is
   PATH_MAX but might cause redefinition warnings when sys/param.h is
   later included (as on MORE/BSD 4.3).  */
   later included (as on MORE/BSD 4.3).  */
#if defined _POSIX_VERSION || (defined HAVE_LIMITS_H && !defined __GNUC__)
#if defined _POSIX_VERSION || (defined HAVE_LIMITS_H && !defined __GNUC__)
# include <limits.h>
# include <limits.h>
#endif
#endif
 
 
#ifndef _POSIX_PATH_MAX
#ifndef _POSIX_PATH_MAX
# define _POSIX_PATH_MAX 255
# define _POSIX_PATH_MAX 255
#endif
#endif
 
 
#if !defined PATH_MAX && defined _PC_PATH_MAX
#if !defined PATH_MAX && defined _PC_PATH_MAX
# define PATH_MAX (pathconf ("/", _PC_PATH_MAX) < 1 ? 1024 : pathconf ("/", _PC_PATH_MAX))
# define PATH_MAX (pathconf ("/", _PC_PATH_MAX) < 1 ? 1024 : pathconf ("/", _PC_PATH_MAX))
#endif
#endif
 
 
/* Don't include sys/param.h if it already has been.  */
/* Don't include sys/param.h if it already has been.  */
#if defined HAVE_SYS_PARAM_H && !defined PATH_MAX && !defined MAXPATHLEN
#if defined HAVE_SYS_PARAM_H && !defined PATH_MAX && !defined MAXPATHLEN
# include <sys/param.h>
# include <sys/param.h>
#endif
#endif
 
 
#if !defined PATH_MAX && defined MAXPATHLEN
#if !defined PATH_MAX && defined MAXPATHLEN
# define PATH_MAX MAXPATHLEN
# define PATH_MAX MAXPATHLEN
#endif
#endif
 
 
#ifndef PATH_MAX
#ifndef PATH_MAX
# define PATH_MAX _POSIX_PATH_MAX
# define PATH_MAX _POSIX_PATH_MAX
#endif
#endif
 
 
/* Pathname support.
/* Pathname support.
   ISSLASH(C)           tests whether C is a directory separator character.
   ISSLASH(C)           tests whether C is a directory separator character.
   IS_ABSOLUTE_PATH(P)  tests whether P is an absolute path.  If it is not,
   IS_ABSOLUTE_PATH(P)  tests whether P is an absolute path.  If it is not,
                        it may be concatenated to a directory pathname.
                        it may be concatenated to a directory pathname.
   IS_PATH_WITH_DIR(P)  tests whether P contains a directory specification.
   IS_PATH_WITH_DIR(P)  tests whether P contains a directory specification.
 */
 */
#if defined _WIN32 || defined __WIN32__ || defined __EMX__ || defined __DJGPP__
#if defined _WIN32 || defined __WIN32__ || defined __EMX__ || defined __DJGPP__
  /* Win32, OS/2, DOS */
  /* Win32, OS/2, DOS */
# define ISSLASH(C) ((C) == '/' || (C) == '\\')
# define ISSLASH(C) ((C) == '/' || (C) == '\\')
# define HAS_DEVICE(P) \
# define HAS_DEVICE(P) \
    ((((P)[0] >= 'A' && (P)[0] <= 'Z') || ((P)[0] >= 'a' && (P)[0] <= 'z')) \
    ((((P)[0] >= 'A' && (P)[0] <= 'Z') || ((P)[0] >= 'a' && (P)[0] <= 'z')) \
     && (P)[1] == ':')
     && (P)[1] == ':')
# define IS_ABSOLUTE_PATH(P) (ISSLASH ((P)[0]) || HAS_DEVICE (P))
# define IS_ABSOLUTE_PATH(P) (ISSLASH ((P)[0]) || HAS_DEVICE (P))
# define IS_PATH_WITH_DIR(P) \
# define IS_PATH_WITH_DIR(P) \
    (strchr (P, '/') != NULL || strchr (P, '\\') != NULL || HAS_DEVICE (P))
    (strchr (P, '/') != NULL || strchr (P, '\\') != NULL || HAS_DEVICE (P))
#else
#else
  /* Unix */
  /* Unix */
# define ISSLASH(C) ((C) == '/')
# define ISSLASH(C) ((C) == '/')
# define IS_ABSOLUTE_PATH(P) ISSLASH ((P)[0])
# define IS_ABSOLUTE_PATH(P) ISSLASH ((P)[0])
# define IS_PATH_WITH_DIR(P) (strchr (P, '/') != NULL)
# define IS_PATH_WITH_DIR(P) (strchr (P, '/') != NULL)
#endif
#endif
 
 
/* This is the type used for the search tree where known translations
/* This is the type used for the search tree where known translations
   are stored.  */
   are stored.  */
struct known_translation_t
struct known_translation_t
{
{
  /* Domain in which to search.  */
  /* Domain in which to search.  */
  char *domainname;
  char *domainname;
 
 
  /* The category.  */
  /* The category.  */
  int category;
  int category;
 
 
  /* State of the catalog counter at the point the string was found.  */
  /* State of the catalog counter at the point the string was found.  */
  int counter;
  int counter;
 
 
  /* Catalog where the string was found.  */
  /* Catalog where the string was found.  */
  struct loaded_l10nfile *domain;
  struct loaded_l10nfile *domain;
 
 
  /* And finally the translation.  */
  /* And finally the translation.  */
  const char *translation;
  const char *translation;
  size_t translation_length;
  size_t translation_length;
 
 
  /* Pointer to the string in question.  */
  /* Pointer to the string in question.  */
  char msgid[ZERO];
  char msgid[ZERO];
};
};
 
 
/* Root of the search tree with known translations.  We can use this
/* Root of the search tree with known translations.  We can use this
   only if the system provides the `tsearch' function family.  */
   only if the system provides the `tsearch' function family.  */
#if defined HAVE_TSEARCH || defined _LIBC
#if defined HAVE_TSEARCH || defined _LIBC
# include <search.h>
# include <search.h>
 
 
static void *root;
static void *root;
 
 
# ifdef _LIBC
# ifdef _LIBC
#  define tsearch __tsearch
#  define tsearch __tsearch
# endif
# endif
 
 
/* Function to compare two entries in the table of known translations.  */
/* Function to compare two entries in the table of known translations.  */
static int transcmp PARAMS ((const void *p1, const void *p2));
static int transcmp PARAMS ((const void *p1, const void *p2));
static int
static int
transcmp (p1, p2)
transcmp (p1, p2)
     const void *p1;
     const void *p1;
     const void *p2;
     const void *p2;
{
{
  const struct known_translation_t *s1;
  const struct known_translation_t *s1;
  const struct known_translation_t *s2;
  const struct known_translation_t *s2;
  int result;
  int result;
 
 
  s1 = (const struct known_translation_t *) p1;
  s1 = (const struct known_translation_t *) p1;
  s2 = (const struct known_translation_t *) p2;
  s2 = (const struct known_translation_t *) p2;
 
 
  result = strcmp (s1->msgid, s2->msgid);
  result = strcmp (s1->msgid, s2->msgid);
  if (result == 0)
  if (result == 0)
    {
    {
      result = strcmp (s1->domainname, s2->domainname);
      result = strcmp (s1->domainname, s2->domainname);
      if (result == 0)
      if (result == 0)
        /* We compare the category last (though this is the cheapest
        /* We compare the category last (though this is the cheapest
           operation) since it is hopefully always the same (namely
           operation) since it is hopefully always the same (namely
           LC_MESSAGES).  */
           LC_MESSAGES).  */
        result = s1->category - s2->category;
        result = s1->category - s2->category;
    }
    }
 
 
  return result;
  return result;
}
}
#endif
#endif
 
 
#ifndef INTVARDEF
#ifndef INTVARDEF
# define INTVARDEF(name)
# define INTVARDEF(name)
#endif
#endif
#ifndef INTUSE
#ifndef INTUSE
# define INTUSE(name) name
# define INTUSE(name) name
#endif
#endif
 
 
/* Name of the default domain used for gettext(3) prior any call to
/* Name of the default domain used for gettext(3) prior any call to
   textdomain(3).  The default value for this is "messages".  */
   textdomain(3).  The default value for this is "messages".  */
const char _nl_default_default_domain[] attribute_hidden = "messages";
const char _nl_default_default_domain[] attribute_hidden = "messages";
 
 
/* Value used as the default domain for gettext(3).  */
/* Value used as the default domain for gettext(3).  */
const char *_nl_current_default_domain attribute_hidden
const char *_nl_current_default_domain attribute_hidden
     = _nl_default_default_domain;
     = _nl_default_default_domain;
 
 
/* Contains the default location of the message catalogs.  */
/* Contains the default location of the message catalogs.  */
#if defined __EMX__
#if defined __EMX__
extern const char _nl_default_dirname[];
extern const char _nl_default_dirname[];
#else
#else
const char _nl_default_dirname[] = LOCALEDIR;
const char _nl_default_dirname[] = LOCALEDIR;
INTVARDEF (_nl_default_dirname)
INTVARDEF (_nl_default_dirname)
#endif
#endif
 
 
/* List with bindings of specific domains created by bindtextdomain()
/* List with bindings of specific domains created by bindtextdomain()
   calls.  */
   calls.  */
struct binding *_nl_domain_bindings;
struct binding *_nl_domain_bindings;
 
 
/* Prototypes for local functions.  */
/* Prototypes for local functions.  */
static char *plural_lookup PARAMS ((struct loaded_l10nfile *domain,
static char *plural_lookup PARAMS ((struct loaded_l10nfile *domain,
                                    unsigned long int n,
                                    unsigned long int n,
                                    const char *translation,
                                    const char *translation,
                                    size_t translation_len))
                                    size_t translation_len))
     internal_function;
     internal_function;
static const char *guess_category_value PARAMS ((int category,
static const char *guess_category_value PARAMS ((int category,
                                                 const char *categoryname))
                                                 const char *categoryname))
     internal_function;
     internal_function;
#ifdef _LIBC
#ifdef _LIBC
# include "../locale/localeinfo.h"
# include "../locale/localeinfo.h"
# define category_to_name(category)     _nl_category_names[category]
# define category_to_name(category)     _nl_category_names[category]
#else
#else
static const char *category_to_name PARAMS ((int category)) internal_function;
static const char *category_to_name PARAMS ((int category)) internal_function;
#endif
#endif
 
 
 
 
/* For those loosing systems which don't have `alloca' we have to add
/* For those loosing systems which don't have `alloca' we have to add
   some additional code emulating it.  */
   some additional code emulating it.  */
#ifdef HAVE_ALLOCA
#ifdef HAVE_ALLOCA
/* Nothing has to be done.  */
/* Nothing has to be done.  */
# define freea(p) /* nothing */
# define freea(p) /* nothing */
# define ADD_BLOCK(list, address) /* nothing */
# define ADD_BLOCK(list, address) /* nothing */
# define FREE_BLOCKS(list) /* nothing */
# define FREE_BLOCKS(list) /* nothing */
#else
#else
struct block_list
struct block_list
{
{
  void *address;
  void *address;
  struct block_list *next;
  struct block_list *next;
};
};
# define ADD_BLOCK(list, addr)                                                \
# define ADD_BLOCK(list, addr)                                                \
  do {                                                                        \
  do {                                                                        \
    struct block_list *newp = (struct block_list *) malloc (sizeof (*newp));  \
    struct block_list *newp = (struct block_list *) malloc (sizeof (*newp));  \
    /* If we cannot get a free block we cannot add the new element to         \
    /* If we cannot get a free block we cannot add the new element to         \
       the list.  */                                                          \
       the list.  */                                                          \
    if (newp != NULL) {                                                       \
    if (newp != NULL) {                                                       \
      newp->address = (addr);                                                 \
      newp->address = (addr);                                                 \
      newp->next = (list);                                                    \
      newp->next = (list);                                                    \
      (list) = newp;                                                          \
      (list) = newp;                                                          \
    }                                                                         \
    }                                                                         \
  } while (0)
  } while (0)
# define FREE_BLOCKS(list)                                                    \
# define FREE_BLOCKS(list)                                                    \
  do {                                                                        \
  do {                                                                        \
    while (list != NULL) {                                                    \
    while (list != NULL) {                                                    \
      struct block_list *old = list;                                          \
      struct block_list *old = list;                                          \
      list = list->next;                                                      \
      list = list->next;                                                      \
      free (old->address);                                                    \
      free (old->address);                                                    \
      free (old);                                                             \
      free (old);                                                             \
    }                                                                         \
    }                                                                         \
  } while (0)
  } while (0)
# undef alloca
# undef alloca
# define alloca(size) (malloc (size))
# define alloca(size) (malloc (size))
# define freea(p) free (p)
# define freea(p) free (p)
#endif  /* have alloca */
#endif  /* have alloca */
 
 
 
 
#ifdef _LIBC
#ifdef _LIBC
/* List of blocks allocated for translations.  */
/* List of blocks allocated for translations.  */
typedef struct transmem_list
typedef struct transmem_list
{
{
  struct transmem_list *next;
  struct transmem_list *next;
  char data[ZERO];
  char data[ZERO];
} transmem_block_t;
} transmem_block_t;
static struct transmem_list *transmem_list;
static struct transmem_list *transmem_list;
#else
#else
typedef unsigned char transmem_block_t;
typedef unsigned char transmem_block_t;
#endif
#endif
 
 
 
 
/* Names for the libintl functions are a problem.  They must not clash
/* Names for the libintl functions are a problem.  They must not clash
   with existing names and they should follow ANSI C.  But this source
   with existing names and they should follow ANSI C.  But this source
   code is also used in GNU C Library where the names have a __
   code is also used in GNU C Library where the names have a __
   prefix.  So we have to make a difference here.  */
   prefix.  So we have to make a difference here.  */
#ifdef _LIBC
#ifdef _LIBC
# define DCIGETTEXT __dcigettext
# define DCIGETTEXT __dcigettext
#else
#else
# define DCIGETTEXT libintl_dcigettext
# define DCIGETTEXT libintl_dcigettext
#endif
#endif
 
 
/* Lock variable to protect the global data in the gettext implementation.  */
/* Lock variable to protect the global data in the gettext implementation.  */
#ifdef _LIBC
#ifdef _LIBC
__libc_rwlock_define_initialized (, _nl_state_lock attribute_hidden)
__libc_rwlock_define_initialized (, _nl_state_lock attribute_hidden)
#endif
#endif
 
 
/* Checking whether the binaries runs SUID must be done and glibc provides
/* Checking whether the binaries runs SUID must be done and glibc provides
   easier methods therefore we make a difference here.  */
   easier methods therefore we make a difference here.  */
#ifdef _LIBC
#ifdef _LIBC
# define ENABLE_SECURE __libc_enable_secure
# define ENABLE_SECURE __libc_enable_secure
# define DETERMINE_SECURE
# define DETERMINE_SECURE
#else
#else
# ifndef HAVE_GETUID
# ifndef HAVE_GETUID
#  define getuid() 0
#  define getuid() 0
# endif
# endif
# ifndef HAVE_GETGID
# ifndef HAVE_GETGID
#  define getgid() 0
#  define getgid() 0
# endif
# endif
# ifndef HAVE_GETEUID
# ifndef HAVE_GETEUID
#  define geteuid() getuid()
#  define geteuid() getuid()
# endif
# endif
# ifndef HAVE_GETEGID
# ifndef HAVE_GETEGID
#  define getegid() getgid()
#  define getegid() getgid()
# endif
# endif
static int enable_secure;
static int enable_secure;
# define ENABLE_SECURE (enable_secure == 1)
# define ENABLE_SECURE (enable_secure == 1)
# define DETERMINE_SECURE \
# define DETERMINE_SECURE \
  if (enable_secure == 0)                                                      \
  if (enable_secure == 0)                                                      \
    {                                                                         \
    {                                                                         \
      if (getuid () != geteuid () || getgid () != getegid ())                 \
      if (getuid () != geteuid () || getgid () != getegid ())                 \
        enable_secure = 1;                                                    \
        enable_secure = 1;                                                    \
      else                                                                    \
      else                                                                    \
        enable_secure = -1;                                                   \
        enable_secure = -1;                                                   \
    }
    }
#endif
#endif
 
 
/* Get the function to evaluate the plural expression.  */
/* Get the function to evaluate the plural expression.  */
#include "eval-plural.h"
#include "eval-plural.h"
 
 
/* Look up MSGID in the DOMAINNAME message catalog for the current
/* Look up MSGID in the DOMAINNAME message catalog for the current
   CATEGORY locale and, if PLURAL is nonzero, search over string
   CATEGORY locale and, if PLURAL is nonzero, search over string
   depending on the plural form determined by N.  */
   depending on the plural form determined by N.  */
char *
char *
DCIGETTEXT (domainname, msgid1, msgid2, plural, n, category)
DCIGETTEXT (domainname, msgid1, msgid2, plural, n, category)
     const char *domainname;
     const char *domainname;
     const char *msgid1;
     const char *msgid1;
     const char *msgid2;
     const char *msgid2;
     int plural;
     int plural;
     unsigned long int n;
     unsigned long int n;
     int category;
     int category;
{
{
#ifndef HAVE_ALLOCA
#ifndef HAVE_ALLOCA
  struct block_list *block_list = NULL;
  struct block_list *block_list = NULL;
#endif
#endif
  struct loaded_l10nfile *domain;
  struct loaded_l10nfile *domain;
  struct binding *binding;
  struct binding *binding;
  const char *categoryname;
  const char *categoryname;
  const char *categoryvalue;
  const char *categoryvalue;
  char *dirname, *xdomainname;
  char *dirname, *xdomainname;
  char *single_locale;
  char *single_locale;
  char *retval;
  char *retval;
  size_t retlen;
  size_t retlen;
  int saved_errno;
  int saved_errno;
#if defined HAVE_TSEARCH || defined _LIBC
#if defined HAVE_TSEARCH || defined _LIBC
  struct known_translation_t *search;
  struct known_translation_t *search;
  struct known_translation_t **foundp = NULL;
  struct known_translation_t **foundp = NULL;
  size_t msgid_len;
  size_t msgid_len;
#endif
#endif
  size_t domainname_len;
  size_t domainname_len;
 
 
  /* If no real MSGID is given return NULL.  */
  /* If no real MSGID is given return NULL.  */
  if (msgid1 == NULL)
  if (msgid1 == NULL)
    return NULL;
    return NULL;
 
 
#ifdef _LIBC
#ifdef _LIBC
  if (category < 0 || category >= __LC_LAST || category == LC_ALL)
  if (category < 0 || category >= __LC_LAST || category == LC_ALL)
    /* Bogus.  */
    /* Bogus.  */
    return (plural == 0
    return (plural == 0
            ? (char *) msgid1
            ? (char *) msgid1
            /* Use the Germanic plural rule.  */
            /* Use the Germanic plural rule.  */
            : n == 1 ? (char *) msgid1 : (char *) msgid2);
            : n == 1 ? (char *) msgid1 : (char *) msgid2);
#endif
#endif
 
 
  __libc_rwlock_rdlock (_nl_state_lock);
  __libc_rwlock_rdlock (_nl_state_lock);
 
 
  /* If DOMAINNAME is NULL, we are interested in the default domain.  If
  /* If DOMAINNAME is NULL, we are interested in the default domain.  If
     CATEGORY is not LC_MESSAGES this might not make much sense but the
     CATEGORY is not LC_MESSAGES this might not make much sense but the
     definition left this undefined.  */
     definition left this undefined.  */
  if (domainname == NULL)
  if (domainname == NULL)
    domainname = _nl_current_default_domain;
    domainname = _nl_current_default_domain;
 
 
  /* OS/2 specific: backward compatibility with older libintl versions  */
  /* OS/2 specific: backward compatibility with older libintl versions  */
#ifdef LC_MESSAGES_COMPAT
#ifdef LC_MESSAGES_COMPAT
  if (category == LC_MESSAGES_COMPAT)
  if (category == LC_MESSAGES_COMPAT)
    category = LC_MESSAGES;
    category = LC_MESSAGES;
#endif
#endif
 
 
#if defined HAVE_TSEARCH || defined _LIBC
#if defined HAVE_TSEARCH || defined _LIBC
  msgid_len = strlen (msgid1) + 1;
  msgid_len = strlen (msgid1) + 1;
 
 
  /* Try to find the translation among those which we found at
  /* Try to find the translation among those which we found at
     some time.  */
     some time.  */
  search = (struct known_translation_t *)
  search = (struct known_translation_t *)
           alloca (offsetof (struct known_translation_t, msgid) + msgid_len);
           alloca (offsetof (struct known_translation_t, msgid) + msgid_len);
  memcpy (search->msgid, msgid1, msgid_len);
  memcpy (search->msgid, msgid1, msgid_len);
  search->domainname = (char *) domainname;
  search->domainname = (char *) domainname;
  search->category = category;
  search->category = category;
 
 
  foundp = (struct known_translation_t **) tfind (search, &root, transcmp);
  foundp = (struct known_translation_t **) tfind (search, &root, transcmp);
  freea (search);
  freea (search);
  if (foundp != NULL && (*foundp)->counter == _nl_msg_cat_cntr)
  if (foundp != NULL && (*foundp)->counter == _nl_msg_cat_cntr)
    {
    {
      /* Now deal with plural.  */
      /* Now deal with plural.  */
      if (plural)
      if (plural)
        retval = plural_lookup ((*foundp)->domain, n, (*foundp)->translation,
        retval = plural_lookup ((*foundp)->domain, n, (*foundp)->translation,
                                (*foundp)->translation_length);
                                (*foundp)->translation_length);
      else
      else
        retval = (char *) (*foundp)->translation;
        retval = (char *) (*foundp)->translation;
 
 
      __libc_rwlock_unlock (_nl_state_lock);
      __libc_rwlock_unlock (_nl_state_lock);
      return retval;
      return retval;
    }
    }
#endif
#endif
 
 
  /* Preserve the `errno' value.  */
  /* Preserve the `errno' value.  */
  saved_errno = errno;
  saved_errno = errno;
 
 
  /* See whether this is a SUID binary or not.  */
  /* See whether this is a SUID binary or not.  */
  DETERMINE_SECURE;
  DETERMINE_SECURE;
 
 
  /* First find matching binding.  */
  /* First find matching binding.  */
  for (binding = _nl_domain_bindings; binding != NULL; binding = binding->next)
  for (binding = _nl_domain_bindings; binding != NULL; binding = binding->next)
    {
    {
      int compare = strcmp (domainname, binding->domainname);
      int compare = strcmp (domainname, binding->domainname);
      if (compare == 0)
      if (compare == 0)
        /* We found it!  */
        /* We found it!  */
        break;
        break;
      if (compare < 0)
      if (compare < 0)
        {
        {
          /* It is not in the list.  */
          /* It is not in the list.  */
          binding = NULL;
          binding = NULL;
          break;
          break;
        }
        }
    }
    }
 
 
  if (binding == NULL)
  if (binding == NULL)
    dirname = (char *) INTUSE(_nl_default_dirname);
    dirname = (char *) INTUSE(_nl_default_dirname);
  else if (IS_ABSOLUTE_PATH (binding->dirname))
  else if (IS_ABSOLUTE_PATH (binding->dirname))
    dirname = binding->dirname;
    dirname = binding->dirname;
  else
  else
    {
    {
      /* We have a relative path.  Make it absolute now.  */
      /* We have a relative path.  Make it absolute now.  */
      size_t dirname_len = strlen (binding->dirname) + 1;
      size_t dirname_len = strlen (binding->dirname) + 1;
      size_t path_max;
      size_t path_max;
      char *ret;
      char *ret;
 
 
      path_max = (unsigned int) PATH_MAX;
      path_max = (unsigned int) PATH_MAX;
      path_max += 2;            /* The getcwd docs say to do this.  */
      path_max += 2;            /* The getcwd docs say to do this.  */
 
 
      for (;;)
      for (;;)
        {
        {
          dirname = (char *) alloca (path_max + dirname_len);
          dirname = (char *) alloca (path_max + dirname_len);
          ADD_BLOCK (block_list, dirname);
          ADD_BLOCK (block_list, dirname);
 
 
          __set_errno (0);
          __set_errno (0);
          ret = getcwd (dirname, path_max);
          ret = getcwd (dirname, path_max);
          if (ret != NULL || errno != ERANGE)
          if (ret != NULL || errno != ERANGE)
            break;
            break;
 
 
          path_max += path_max / 2;
          path_max += path_max / 2;
          path_max += PATH_INCR;
          path_max += PATH_INCR;
        }
        }
 
 
      if (ret == NULL)
      if (ret == NULL)
        /* We cannot get the current working directory.  Don't signal an
        /* We cannot get the current working directory.  Don't signal an
           error but simply return the default string.  */
           error but simply return the default string.  */
        goto return_untranslated;
        goto return_untranslated;
 
 
      stpcpy (stpcpy (strchr (dirname, '\0'), "/"), binding->dirname);
      stpcpy (stpcpy (strchr (dirname, '\0'), "/"), binding->dirname);
    }
    }
 
 
  /* Now determine the symbolic name of CATEGORY and its value.  */
  /* Now determine the symbolic name of CATEGORY and its value.  */
  categoryname = category_to_name (category);
  categoryname = category_to_name (category);
  categoryvalue = guess_category_value (category, categoryname);
  categoryvalue = guess_category_value (category, categoryname);
 
 
  domainname_len = strlen (domainname);
  domainname_len = strlen (domainname);
  xdomainname = (char *) alloca (strlen (categoryname)
  xdomainname = (char *) alloca (strlen (categoryname)
                                 + domainname_len + 5);
                                 + domainname_len + 5);
  ADD_BLOCK (block_list, xdomainname);
  ADD_BLOCK (block_list, xdomainname);
 
 
  stpcpy (mempcpy (stpcpy (stpcpy (xdomainname, categoryname), "/"),
  stpcpy (mempcpy (stpcpy (stpcpy (xdomainname, categoryname), "/"),
                  domainname, domainname_len),
                  domainname, domainname_len),
          ".mo");
          ".mo");
 
 
  /* Creating working area.  */
  /* Creating working area.  */
  single_locale = (char *) alloca (strlen (categoryvalue) + 1);
  single_locale = (char *) alloca (strlen (categoryvalue) + 1);
  ADD_BLOCK (block_list, single_locale);
  ADD_BLOCK (block_list, single_locale);
 
 
 
 
  /* Search for the given string.  This is a loop because we perhaps
  /* Search for the given string.  This is a loop because we perhaps
     got an ordered list of languages to consider for the translation.  */
     got an ordered list of languages to consider for the translation.  */
  while (1)
  while (1)
    {
    {
      /* Make CATEGORYVALUE point to the next element of the list.  */
      /* Make CATEGORYVALUE point to the next element of the list.  */
      while (categoryvalue[0] != '\0' && categoryvalue[0] == ':')
      while (categoryvalue[0] != '\0' && categoryvalue[0] == ':')
        ++categoryvalue;
        ++categoryvalue;
      if (categoryvalue[0] == '\0')
      if (categoryvalue[0] == '\0')
        {
        {
          /* The whole contents of CATEGORYVALUE has been searched but
          /* The whole contents of CATEGORYVALUE has been searched but
             no valid entry has been found.  We solve this situation
             no valid entry has been found.  We solve this situation
             by implicitly appending a "C" entry, i.e. no translation
             by implicitly appending a "C" entry, i.e. no translation
             will take place.  */
             will take place.  */
          single_locale[0] = 'C';
          single_locale[0] = 'C';
          single_locale[1] = '\0';
          single_locale[1] = '\0';
        }
        }
      else
      else
        {
        {
          char *cp = single_locale;
          char *cp = single_locale;
          while (categoryvalue[0] != '\0' && categoryvalue[0] != ':')
          while (categoryvalue[0] != '\0' && categoryvalue[0] != ':')
            *cp++ = *categoryvalue++;
            *cp++ = *categoryvalue++;
          *cp = '\0';
          *cp = '\0';
 
 
          /* When this is a SUID binary we must not allow accessing files
          /* When this is a SUID binary we must not allow accessing files
             outside the dedicated directories.  */
             outside the dedicated directories.  */
          if (ENABLE_SECURE && IS_PATH_WITH_DIR (single_locale))
          if (ENABLE_SECURE && IS_PATH_WITH_DIR (single_locale))
            /* Ingore this entry.  */
            /* Ingore this entry.  */
            continue;
            continue;
        }
        }
 
 
      /* If the current locale value is C (or POSIX) we don't load a
      /* If the current locale value is C (or POSIX) we don't load a
         domain.  Return the MSGID.  */
         domain.  Return the MSGID.  */
      if (strcmp (single_locale, "C") == 0
      if (strcmp (single_locale, "C") == 0
          || strcmp (single_locale, "POSIX") == 0)
          || strcmp (single_locale, "POSIX") == 0)
        break;
        break;
 
 
      /* Find structure describing the message catalog matching the
      /* Find structure describing the message catalog matching the
         DOMAINNAME and CATEGORY.  */
         DOMAINNAME and CATEGORY.  */
      domain = _nl_find_domain (dirname, single_locale, xdomainname, binding);
      domain = _nl_find_domain (dirname, single_locale, xdomainname, binding);
 
 
      if (domain != NULL)
      if (domain != NULL)
        {
        {
          retval = _nl_find_msg (domain, binding, msgid1, &retlen);
          retval = _nl_find_msg (domain, binding, msgid1, &retlen);
 
 
          if (retval == NULL)
          if (retval == NULL)
            {
            {
              int cnt;
              int cnt;
 
 
              for (cnt = 0; domain->successor[cnt] != NULL; ++cnt)
              for (cnt = 0; domain->successor[cnt] != NULL; ++cnt)
                {
                {
                  retval = _nl_find_msg (domain->successor[cnt], binding,
                  retval = _nl_find_msg (domain->successor[cnt], binding,
                                         msgid1, &retlen);
                                         msgid1, &retlen);
 
 
                  if (retval != NULL)
                  if (retval != NULL)
                    {
                    {
                      domain = domain->successor[cnt];
                      domain = domain->successor[cnt];
                      break;
                      break;
                    }
                    }
                }
                }
            }
            }
 
 
          if (retval != NULL)
          if (retval != NULL)
            {
            {
              /* Found the translation of MSGID1 in domain DOMAIN:
              /* Found the translation of MSGID1 in domain DOMAIN:
                 starting at RETVAL, RETLEN bytes.  */
                 starting at RETVAL, RETLEN bytes.  */
              FREE_BLOCKS (block_list);
              FREE_BLOCKS (block_list);
#if defined HAVE_TSEARCH || defined _LIBC
#if defined HAVE_TSEARCH || defined _LIBC
              if (foundp == NULL)
              if (foundp == NULL)
                {
                {
                  /* Create a new entry and add it to the search tree.  */
                  /* Create a new entry and add it to the search tree.  */
                  struct known_translation_t *newp;
                  struct known_translation_t *newp;
 
 
                  newp = (struct known_translation_t *)
                  newp = (struct known_translation_t *)
                    malloc (offsetof (struct known_translation_t, msgid)
                    malloc (offsetof (struct known_translation_t, msgid)
                            + msgid_len + domainname_len + 1);
                            + msgid_len + domainname_len + 1);
                  if (newp != NULL)
                  if (newp != NULL)
                    {
                    {
                      newp->domainname =
                      newp->domainname =
                        mempcpy (newp->msgid, msgid1, msgid_len);
                        mempcpy (newp->msgid, msgid1, msgid_len);
                      memcpy (newp->domainname, domainname, domainname_len + 1);
                      memcpy (newp->domainname, domainname, domainname_len + 1);
                      newp->category = category;
                      newp->category = category;
                      newp->counter = _nl_msg_cat_cntr;
                      newp->counter = _nl_msg_cat_cntr;
                      newp->domain = domain;
                      newp->domain = domain;
                      newp->translation = retval;
                      newp->translation = retval;
                      newp->translation_length = retlen;
                      newp->translation_length = retlen;
 
 
                      /* Insert the entry in the search tree.  */
                      /* Insert the entry in the search tree.  */
                      foundp = (struct known_translation_t **)
                      foundp = (struct known_translation_t **)
                        tsearch (newp, &root, transcmp);
                        tsearch (newp, &root, transcmp);
                      if (foundp == NULL
                      if (foundp == NULL
                          || __builtin_expect (*foundp != newp, 0))
                          || __builtin_expect (*foundp != newp, 0))
                        /* The insert failed.  */
                        /* The insert failed.  */
                        free (newp);
                        free (newp);
                    }
                    }
                }
                }
              else
              else
                {
                {
                  /* We can update the existing entry.  */
                  /* We can update the existing entry.  */
                  (*foundp)->counter = _nl_msg_cat_cntr;
                  (*foundp)->counter = _nl_msg_cat_cntr;
                  (*foundp)->domain = domain;
                  (*foundp)->domain = domain;
                  (*foundp)->translation = retval;
                  (*foundp)->translation = retval;
                  (*foundp)->translation_length = retlen;
                  (*foundp)->translation_length = retlen;
                }
                }
#endif
#endif
              __set_errno (saved_errno);
              __set_errno (saved_errno);
 
 
              /* Now deal with plural.  */
              /* Now deal with plural.  */
              if (plural)
              if (plural)
                retval = plural_lookup (domain, n, retval, retlen);
                retval = plural_lookup (domain, n, retval, retlen);
 
 
              __libc_rwlock_unlock (_nl_state_lock);
              __libc_rwlock_unlock (_nl_state_lock);
              return retval;
              return retval;
            }
            }
        }
        }
    }
    }
 
 
 return_untranslated:
 return_untranslated:
  /* Return the untranslated MSGID.  */
  /* Return the untranslated MSGID.  */
  FREE_BLOCKS (block_list);
  FREE_BLOCKS (block_list);
  __libc_rwlock_unlock (_nl_state_lock);
  __libc_rwlock_unlock (_nl_state_lock);
#ifndef _LIBC
#ifndef _LIBC
  if (!ENABLE_SECURE)
  if (!ENABLE_SECURE)
    {
    {
      extern void _nl_log_untranslated PARAMS ((const char *logfilename,
      extern void _nl_log_untranslated PARAMS ((const char *logfilename,
                                                const char *domainname,
                                                const char *domainname,
                                                const char *msgid1,
                                                const char *msgid1,
                                                const char *msgid2,
                                                const char *msgid2,
                                                int plural));
                                                int plural));
      const char *logfilename = getenv ("GETTEXT_LOG_UNTRANSLATED");
      const char *logfilename = getenv ("GETTEXT_LOG_UNTRANSLATED");
 
 
      if (logfilename != NULL && logfilename[0] != '\0')
      if (logfilename != NULL && logfilename[0] != '\0')
        _nl_log_untranslated (logfilename, domainname, msgid1, msgid2, plural);
        _nl_log_untranslated (logfilename, domainname, msgid1, msgid2, plural);
    }
    }
#endif
#endif
  __set_errno (saved_errno);
  __set_errno (saved_errno);
  return (plural == 0
  return (plural == 0
          ? (char *) msgid1
          ? (char *) msgid1
          /* Use the Germanic plural rule.  */
          /* Use the Germanic plural rule.  */
          : n == 1 ? (char *) msgid1 : (char *) msgid2);
          : n == 1 ? (char *) msgid1 : (char *) msgid2);
}
}
 
 
 
 
char *
char *
internal_function
internal_function
_nl_find_msg (domain_file, domainbinding, msgid, lengthp)
_nl_find_msg (domain_file, domainbinding, msgid, lengthp)
     struct loaded_l10nfile *domain_file;
     struct loaded_l10nfile *domain_file;
     struct binding *domainbinding;
     struct binding *domainbinding;
     const char *msgid;
     const char *msgid;
     size_t *lengthp;
     size_t *lengthp;
{
{
  struct loaded_domain *domain;
  struct loaded_domain *domain;
  nls_uint32 nstrings;
  nls_uint32 nstrings;
  size_t act;
  size_t act;
  char *result;
  char *result;
  size_t resultlen;
  size_t resultlen;
 
 
  if (domain_file->decided == 0)
  if (domain_file->decided == 0)
    _nl_load_domain (domain_file, domainbinding);
    _nl_load_domain (domain_file, domainbinding);
 
 
  if (domain_file->data == NULL)
  if (domain_file->data == NULL)
    return NULL;
    return NULL;
 
 
  domain = (struct loaded_domain *) domain_file->data;
  domain = (struct loaded_domain *) domain_file->data;
 
 
  nstrings = domain->nstrings;
  nstrings = domain->nstrings;
 
 
  /* Locate the MSGID and its translation.  */
  /* Locate the MSGID and its translation.  */
  if (domain->hash_tab != NULL)
  if (domain->hash_tab != NULL)
    {
    {
      /* Use the hashing table.  */
      /* Use the hashing table.  */
      nls_uint32 len = strlen (msgid);
      nls_uint32 len = strlen (msgid);
      nls_uint32 hash_val = hash_string (msgid);
      nls_uint32 hash_val = hash_string (msgid);
      nls_uint32 idx = hash_val % domain->hash_size;
      nls_uint32 idx = hash_val % domain->hash_size;
      nls_uint32 incr = 1 + (hash_val % (domain->hash_size - 2));
      nls_uint32 incr = 1 + (hash_val % (domain->hash_size - 2));
 
 
      while (1)
      while (1)
        {
        {
          nls_uint32 nstr =
          nls_uint32 nstr =
            W (domain->must_swap_hash_tab, domain->hash_tab[idx]);
            W (domain->must_swap_hash_tab, domain->hash_tab[idx]);
 
 
          if (nstr == 0)
          if (nstr == 0)
            /* Hash table entry is empty.  */
            /* Hash table entry is empty.  */
            return NULL;
            return NULL;
 
 
          nstr--;
          nstr--;
 
 
          /* Compare msgid with the original string at index nstr.
          /* Compare msgid with the original string at index nstr.
             We compare the lengths with >=, not ==, because plural entries
             We compare the lengths with >=, not ==, because plural entries
             are represented by strings with an embedded NUL.  */
             are represented by strings with an embedded NUL.  */
          if (nstr < nstrings
          if (nstr < nstrings
              ? W (domain->must_swap, domain->orig_tab[nstr].length) >= len
              ? W (domain->must_swap, domain->orig_tab[nstr].length) >= len
                && (strcmp (msgid,
                && (strcmp (msgid,
                            domain->data + W (domain->must_swap,
                            domain->data + W (domain->must_swap,
                                              domain->orig_tab[nstr].offset))
                                              domain->orig_tab[nstr].offset))
                    == 0)
                    == 0)
              : domain->orig_sysdep_tab[nstr - nstrings].length > len
              : domain->orig_sysdep_tab[nstr - nstrings].length > len
                && (strcmp (msgid,
                && (strcmp (msgid,
                            domain->orig_sysdep_tab[nstr - nstrings].pointer)
                            domain->orig_sysdep_tab[nstr - nstrings].pointer)
                    == 0))
                    == 0))
            {
            {
              act = nstr;
              act = nstr;
              goto found;
              goto found;
            }
            }
 
 
          if (idx >= domain->hash_size - incr)
          if (idx >= domain->hash_size - incr)
            idx -= domain->hash_size - incr;
            idx -= domain->hash_size - incr;
          else
          else
            idx += incr;
            idx += incr;
        }
        }
      /* NOTREACHED */
      /* NOTREACHED */
    }
    }
  else
  else
    {
    {
      /* Try the default method:  binary search in the sorted array of
      /* Try the default method:  binary search in the sorted array of
         messages.  */
         messages.  */
      size_t top, bottom;
      size_t top, bottom;
 
 
      bottom = 0;
      bottom = 0;
      top = nstrings;
      top = nstrings;
      while (bottom < top)
      while (bottom < top)
        {
        {
          int cmp_val;
          int cmp_val;
 
 
          act = (bottom + top) / 2;
          act = (bottom + top) / 2;
          cmp_val = strcmp (msgid, (domain->data
          cmp_val = strcmp (msgid, (domain->data
                                    + W (domain->must_swap,
                                    + W (domain->must_swap,
                                         domain->orig_tab[act].offset)));
                                         domain->orig_tab[act].offset)));
          if (cmp_val < 0)
          if (cmp_val < 0)
            top = act;
            top = act;
          else if (cmp_val > 0)
          else if (cmp_val > 0)
            bottom = act + 1;
            bottom = act + 1;
          else
          else
            goto found;
            goto found;
        }
        }
      /* No translation was found.  */
      /* No translation was found.  */
      return NULL;
      return NULL;
    }
    }
 
 
 found:
 found:
  /* The translation was found at index ACT.  If we have to convert the
  /* The translation was found at index ACT.  If we have to convert the
     string to use a different character set, this is the time.  */
     string to use a different character set, this is the time.  */
  if (act < nstrings)
  if (act < nstrings)
    {
    {
      result = (char *)
      result = (char *)
        (domain->data + W (domain->must_swap, domain->trans_tab[act].offset));
        (domain->data + W (domain->must_swap, domain->trans_tab[act].offset));
      resultlen = W (domain->must_swap, domain->trans_tab[act].length) + 1;
      resultlen = W (domain->must_swap, domain->trans_tab[act].length) + 1;
    }
    }
  else
  else
    {
    {
      result = (char *) domain->trans_sysdep_tab[act - nstrings].pointer;
      result = (char *) domain->trans_sysdep_tab[act - nstrings].pointer;
      resultlen = domain->trans_sysdep_tab[act - nstrings].length;
      resultlen = domain->trans_sysdep_tab[act - nstrings].length;
    }
    }
 
 
#if defined _LIBC || HAVE_ICONV
#if defined _LIBC || HAVE_ICONV
  if (domain->codeset_cntr
  if (domain->codeset_cntr
      != (domainbinding != NULL ? domainbinding->codeset_cntr : 0))
      != (domainbinding != NULL ? domainbinding->codeset_cntr : 0))
    {
    {
      /* The domain's codeset has changed through bind_textdomain_codeset()
      /* The domain's codeset has changed through bind_textdomain_codeset()
         since the message catalog was initialized or last accessed.  We
         since the message catalog was initialized or last accessed.  We
         have to reinitialize the converter.  */
         have to reinitialize the converter.  */
      _nl_free_domain_conv (domain);
      _nl_free_domain_conv (domain);
      _nl_init_domain_conv (domain_file, domain, domainbinding);
      _nl_init_domain_conv (domain_file, domain, domainbinding);
    }
    }
 
 
  if (
  if (
# ifdef _LIBC
# ifdef _LIBC
      domain->conv != (__gconv_t) -1
      domain->conv != (__gconv_t) -1
# else
# else
#  if HAVE_ICONV
#  if HAVE_ICONV
      domain->conv != (iconv_t) -1
      domain->conv != (iconv_t) -1
#  endif
#  endif
# endif
# endif
      )
      )
    {
    {
      /* We are supposed to do a conversion.  First allocate an
      /* We are supposed to do a conversion.  First allocate an
         appropriate table with the same structure as the table
         appropriate table with the same structure as the table
         of translations in the file, where we can put the pointers
         of translations in the file, where we can put the pointers
         to the converted strings in.
         to the converted strings in.
         There is a slight complication with plural entries.  They
         There is a slight complication with plural entries.  They
         are represented by consecutive NUL terminated strings.  We
         are represented by consecutive NUL terminated strings.  We
         handle this case by converting RESULTLEN bytes, including
         handle this case by converting RESULTLEN bytes, including
         NULs.  */
         NULs.  */
 
 
      if (domain->conv_tab == NULL
      if (domain->conv_tab == NULL
          && ((domain->conv_tab =
          && ((domain->conv_tab =
                 (char **) calloc (nstrings + domain->n_sysdep_strings,
                 (char **) calloc (nstrings + domain->n_sysdep_strings,
                                   sizeof (char *)))
                                   sizeof (char *)))
              == NULL))
              == NULL))
        /* Mark that we didn't succeed allocating a table.  */
        /* Mark that we didn't succeed allocating a table.  */
        domain->conv_tab = (char **) -1;
        domain->conv_tab = (char **) -1;
 
 
      if (__builtin_expect (domain->conv_tab == (char **) -1, 0))
      if (__builtin_expect (domain->conv_tab == (char **) -1, 0))
        /* Nothing we can do, no more memory.  */
        /* Nothing we can do, no more memory.  */
        goto converted;
        goto converted;
 
 
      if (domain->conv_tab[act] == NULL)
      if (domain->conv_tab[act] == NULL)
        {
        {
          /* We haven't used this string so far, so it is not
          /* We haven't used this string so far, so it is not
             translated yet.  Do this now.  */
             translated yet.  Do this now.  */
          /* We use a bit more efficient memory handling.
          /* We use a bit more efficient memory handling.
             We allocate always larger blocks which get used over
             We allocate always larger blocks which get used over
             time.  This is faster than many small allocations.   */
             time.  This is faster than many small allocations.   */
          __libc_lock_define_initialized (static, lock)
          __libc_lock_define_initialized (static, lock)
# define INITIAL_BLOCK_SIZE     4080
# define INITIAL_BLOCK_SIZE     4080
          static unsigned char *freemem;
          static unsigned char *freemem;
          static size_t freemem_size;
          static size_t freemem_size;
 
 
          const unsigned char *inbuf;
          const unsigned char *inbuf;
          unsigned char *outbuf;
          unsigned char *outbuf;
          int malloc_count;
          int malloc_count;
# ifndef _LIBC
# ifndef _LIBC
          transmem_block_t *transmem_list = NULL;
          transmem_block_t *transmem_list = NULL;
# endif
# endif
 
 
          __libc_lock_lock (lock);
          __libc_lock_lock (lock);
 
 
          inbuf = (const unsigned char *) result;
          inbuf = (const unsigned char *) result;
          outbuf = freemem + sizeof (size_t);
          outbuf = freemem + sizeof (size_t);
 
 
          malloc_count = 0;
          malloc_count = 0;
          while (1)
          while (1)
            {
            {
              transmem_block_t *newmem;
              transmem_block_t *newmem;
# ifdef _LIBC
# ifdef _LIBC
              size_t non_reversible;
              size_t non_reversible;
              int res;
              int res;
 
 
              if (freemem_size < sizeof (size_t))
              if (freemem_size < sizeof (size_t))
                goto resize_freemem;
                goto resize_freemem;
 
 
              res = __gconv (domain->conv,
              res = __gconv (domain->conv,
                             &inbuf, inbuf + resultlen,
                             &inbuf, inbuf + resultlen,
                             &outbuf,
                             &outbuf,
                             outbuf + freemem_size - sizeof (size_t),
                             outbuf + freemem_size - sizeof (size_t),
                             &non_reversible);
                             &non_reversible);
 
 
              if (res == __GCONV_OK || res == __GCONV_EMPTY_INPUT)
              if (res == __GCONV_OK || res == __GCONV_EMPTY_INPUT)
                break;
                break;
 
 
              if (res != __GCONV_FULL_OUTPUT)
              if (res != __GCONV_FULL_OUTPUT)
                {
                {
                  __libc_lock_unlock (lock);
                  __libc_lock_unlock (lock);
                  goto converted;
                  goto converted;
                }
                }
 
 
              inbuf = result;
              inbuf = result;
# else
# else
#  if HAVE_ICONV
#  if HAVE_ICONV
              const char *inptr = (const char *) inbuf;
              const char *inptr = (const char *) inbuf;
              size_t inleft = resultlen;
              size_t inleft = resultlen;
              char *outptr = (char *) outbuf;
              char *outptr = (char *) outbuf;
              size_t outleft;
              size_t outleft;
 
 
              if (freemem_size < sizeof (size_t))
              if (freemem_size < sizeof (size_t))
                goto resize_freemem;
                goto resize_freemem;
 
 
              outleft = freemem_size - sizeof (size_t);
              outleft = freemem_size - sizeof (size_t);
              if (iconv (domain->conv,
              if (iconv (domain->conv,
                         (ICONV_CONST char **) &inptr, &inleft,
                         (ICONV_CONST char **) &inptr, &inleft,
                         &outptr, &outleft)
                         &outptr, &outleft)
                  != (size_t) (-1))
                  != (size_t) (-1))
                {
                {
                  outbuf = (unsigned char *) outptr;
                  outbuf = (unsigned char *) outptr;
                  break;
                  break;
                }
                }
              if (errno != E2BIG)
              if (errno != E2BIG)
                {
                {
                  __libc_lock_unlock (lock);
                  __libc_lock_unlock (lock);
                  goto converted;
                  goto converted;
                }
                }
#  endif
#  endif
# endif
# endif
 
 
            resize_freemem:
            resize_freemem:
              /* We must allocate a new buffer or resize the old one.  */
              /* We must allocate a new buffer or resize the old one.  */
              if (malloc_count > 0)
              if (malloc_count > 0)
                {
                {
                  ++malloc_count;
                  ++malloc_count;
                  freemem_size = malloc_count * INITIAL_BLOCK_SIZE;
                  freemem_size = malloc_count * INITIAL_BLOCK_SIZE;
                  newmem = (transmem_block_t *) realloc (transmem_list,
                  newmem = (transmem_block_t *) realloc (transmem_list,
                                                         freemem_size);
                                                         freemem_size);
# ifdef _LIBC
# ifdef _LIBC
                  if (newmem != NULL)
                  if (newmem != NULL)
                    transmem_list = transmem_list->next;
                    transmem_list = transmem_list->next;
                  else
                  else
                    {
                    {
                      struct transmem_list *old = transmem_list;
                      struct transmem_list *old = transmem_list;
 
 
                      transmem_list = transmem_list->next;
                      transmem_list = transmem_list->next;
                      free (old);
                      free (old);
                    }
                    }
# endif
# endif
                }
                }
              else
              else
                {
                {
                  malloc_count = 1;
                  malloc_count = 1;
                  freemem_size = INITIAL_BLOCK_SIZE;
                  freemem_size = INITIAL_BLOCK_SIZE;
                  newmem = (transmem_block_t *) malloc (freemem_size);
                  newmem = (transmem_block_t *) malloc (freemem_size);
                }
                }
              if (__builtin_expect (newmem == NULL, 0))
              if (__builtin_expect (newmem == NULL, 0))
                {
                {
                  freemem = NULL;
                  freemem = NULL;
                  freemem_size = 0;
                  freemem_size = 0;
                  __libc_lock_unlock (lock);
                  __libc_lock_unlock (lock);
                  goto converted;
                  goto converted;
                }
                }
 
 
# ifdef _LIBC
# ifdef _LIBC
              /* Add the block to the list of blocks we have to free
              /* Add the block to the list of blocks we have to free
                 at some point.  */
                 at some point.  */
              newmem->next = transmem_list;
              newmem->next = transmem_list;
              transmem_list = newmem;
              transmem_list = newmem;
 
 
              freemem = newmem->data;
              freemem = newmem->data;
              freemem_size -= offsetof (struct transmem_list, data);
              freemem_size -= offsetof (struct transmem_list, data);
# else
# else
              transmem_list = newmem;
              transmem_list = newmem;
              freemem = newmem;
              freemem = newmem;
# endif
# endif
 
 
              outbuf = freemem + sizeof (size_t);
              outbuf = freemem + sizeof (size_t);
            }
            }
 
 
          /* We have now in our buffer a converted string.  Put this
          /* We have now in our buffer a converted string.  Put this
             into the table of conversions.  */
             into the table of conversions.  */
          *(size_t *) freemem = outbuf - freemem - sizeof (size_t);
          *(size_t *) freemem = outbuf - freemem - sizeof (size_t);
          domain->conv_tab[act] = (char *) freemem;
          domain->conv_tab[act] = (char *) freemem;
          /* Shrink freemem, but keep it aligned.  */
          /* Shrink freemem, but keep it aligned.  */
          freemem_size -= outbuf - freemem;
          freemem_size -= outbuf - freemem;
          freemem = outbuf;
          freemem = outbuf;
          freemem += freemem_size & (alignof (size_t) - 1);
          freemem += freemem_size & (alignof (size_t) - 1);
          freemem_size = freemem_size & ~ (alignof (size_t) - 1);
          freemem_size = freemem_size & ~ (alignof (size_t) - 1);
 
 
          __libc_lock_unlock (lock);
          __libc_lock_unlock (lock);
        }
        }
 
 
      /* Now domain->conv_tab[act] contains the translation of all
      /* Now domain->conv_tab[act] contains the translation of all
         the plural variants.  */
         the plural variants.  */
      result = domain->conv_tab[act] + sizeof (size_t);
      result = domain->conv_tab[act] + sizeof (size_t);
      resultlen = *(size_t *) domain->conv_tab[act];
      resultlen = *(size_t *) domain->conv_tab[act];
    }
    }
 
 
 converted:
 converted:
  /* The result string is converted.  */
  /* The result string is converted.  */
 
 
#endif /* _LIBC || HAVE_ICONV */
#endif /* _LIBC || HAVE_ICONV */
 
 
  *lengthp = resultlen;
  *lengthp = resultlen;
  return result;
  return result;
}
}
 
 
 
 
/* Look up a plural variant.  */
/* Look up a plural variant.  */
static char *
static char *
internal_function
internal_function
plural_lookup (domain, n, translation, translation_len)
plural_lookup (domain, n, translation, translation_len)
     struct loaded_l10nfile *domain;
     struct loaded_l10nfile *domain;
     unsigned long int n;
     unsigned long int n;
     const char *translation;
     const char *translation;
     size_t translation_len;
     size_t translation_len;
{
{
  struct loaded_domain *domaindata = (struct loaded_domain *) domain->data;
  struct loaded_domain *domaindata = (struct loaded_domain *) domain->data;
  unsigned long int index;
  unsigned long int index;
  const char *p;
  const char *p;
 
 
  index = plural_eval (domaindata->plural, n);
  index = plural_eval (domaindata->plural, n);
  if (index >= domaindata->nplurals)
  if (index >= domaindata->nplurals)
    /* This should never happen.  It means the plural expression and the
    /* This should never happen.  It means the plural expression and the
       given maximum value do not match.  */
       given maximum value do not match.  */
    index = 0;
    index = 0;
 
 
  /* Skip INDEX strings at TRANSLATION.  */
  /* Skip INDEX strings at TRANSLATION.  */
  p = translation;
  p = translation;
  while (index-- > 0)
  while (index-- > 0)
    {
    {
#ifdef _LIBC
#ifdef _LIBC
      p = __rawmemchr (p, '\0');
      p = __rawmemchr (p, '\0');
#else
#else
      p = strchr (p, '\0');
      p = strchr (p, '\0');
#endif
#endif
      /* And skip over the NUL byte.  */
      /* And skip over the NUL byte.  */
      p++;
      p++;
 
 
      if (p >= translation + translation_len)
      if (p >= translation + translation_len)
        /* This should never happen.  It means the plural expression
        /* This should never happen.  It means the plural expression
           evaluated to a value larger than the number of variants
           evaluated to a value larger than the number of variants
           available for MSGID1.  */
           available for MSGID1.  */
        return (char *) translation;
        return (char *) translation;
    }
    }
  return (char *) p;
  return (char *) p;
}
}
 
 
#ifndef _LIBC
#ifndef _LIBC
/* Return string representation of locale CATEGORY.  */
/* Return string representation of locale CATEGORY.  */
static const char *
static const char *
internal_function
internal_function
category_to_name (category)
category_to_name (category)
     int category;
     int category;
{
{
  const char *retval;
  const char *retval;
 
 
  switch (category)
  switch (category)
  {
  {
#ifdef LC_COLLATE
#ifdef LC_COLLATE
  case LC_COLLATE:
  case LC_COLLATE:
    retval = "LC_COLLATE";
    retval = "LC_COLLATE";
    break;
    break;
#endif
#endif
#ifdef LC_CTYPE
#ifdef LC_CTYPE
  case LC_CTYPE:
  case LC_CTYPE:
    retval = "LC_CTYPE";
    retval = "LC_CTYPE";
    break;
    break;
#endif
#endif
#ifdef LC_MONETARY
#ifdef LC_MONETARY
  case LC_MONETARY:
  case LC_MONETARY:
    retval = "LC_MONETARY";
    retval = "LC_MONETARY";
    break;
    break;
#endif
#endif
#ifdef LC_NUMERIC
#ifdef LC_NUMERIC
  case LC_NUMERIC:
  case LC_NUMERIC:
    retval = "LC_NUMERIC";
    retval = "LC_NUMERIC";
    break;
    break;
#endif
#endif
#ifdef LC_TIME
#ifdef LC_TIME
  case LC_TIME:
  case LC_TIME:
    retval = "LC_TIME";
    retval = "LC_TIME";
    break;
    break;
#endif
#endif
#ifdef LC_MESSAGES
#ifdef LC_MESSAGES
  case LC_MESSAGES:
  case LC_MESSAGES:
    retval = "LC_MESSAGES";
    retval = "LC_MESSAGES";
    break;
    break;
#endif
#endif
#ifdef LC_RESPONSE
#ifdef LC_RESPONSE
  case LC_RESPONSE:
  case LC_RESPONSE:
    retval = "LC_RESPONSE";
    retval = "LC_RESPONSE";
    break;
    break;
#endif
#endif
#ifdef LC_ALL
#ifdef LC_ALL
  case LC_ALL:
  case LC_ALL:
    /* This might not make sense but is perhaps better than any other
    /* This might not make sense but is perhaps better than any other
       value.  */
       value.  */
    retval = "LC_ALL";
    retval = "LC_ALL";
    break;
    break;
#endif
#endif
  default:
  default:
    /* If you have a better idea for a default value let me know.  */
    /* If you have a better idea for a default value let me know.  */
    retval = "LC_XXX";
    retval = "LC_XXX";
  }
  }
 
 
  return retval;
  return retval;
}
}
#endif
#endif
 
 
/* Guess value of current locale from value of the environment variables.  */
/* Guess value of current locale from value of the environment variables.  */
static const char *
static const char *
internal_function
internal_function
guess_category_value (category, categoryname)
guess_category_value (category, categoryname)
     int category;
     int category;
     const char *categoryname;
     const char *categoryname;
{
{
  const char *language;
  const char *language;
  const char *retval;
  const char *retval;
 
 
  /* The highest priority value is the `LANGUAGE' environment
  /* The highest priority value is the `LANGUAGE' environment
     variable.  But we don't use the value if the currently selected
     variable.  But we don't use the value if the currently selected
     locale is the C locale.  This is a GNU extension.  */
     locale is the C locale.  This is a GNU extension.  */
  language = getenv ("LANGUAGE");
  language = getenv ("LANGUAGE");
  if (language != NULL && language[0] == '\0')
  if (language != NULL && language[0] == '\0')
    language = NULL;
    language = NULL;
 
 
  /* We have to proceed with the POSIX methods of looking to `LC_ALL',
  /* We have to proceed with the POSIX methods of looking to `LC_ALL',
     `LC_xxx', and `LANG'.  On some systems this can be done by the
     `LC_xxx', and `LANG'.  On some systems this can be done by the
     `setlocale' function itself.  */
     `setlocale' function itself.  */
#ifdef _LIBC
#ifdef _LIBC
  retval = __current_locale_name (category);
  retval = __current_locale_name (category);
#else
#else
  retval = _nl_locale_name (category, categoryname);
  retval = _nl_locale_name (category, categoryname);
#endif
#endif
 
 
  /* Ignore LANGUAGE if the locale is set to "C" because
  /* Ignore LANGUAGE if the locale is set to "C" because
     1. "C" locale usually uses the ASCII encoding, and most international
     1. "C" locale usually uses the ASCII encoding, and most international
        messages use non-ASCII characters. These characters get displayed
        messages use non-ASCII characters. These characters get displayed
        as question marks (if using glibc's iconv()) or as invalid 8-bit
        as question marks (if using glibc's iconv()) or as invalid 8-bit
        characters (because other iconv()s refuse to convert most non-ASCII
        characters (because other iconv()s refuse to convert most non-ASCII
        characters to ASCII). In any case, the output is ugly.
        characters to ASCII). In any case, the output is ugly.
     2. The precise output of some programs in the "C" locale is specified
     2. The precise output of some programs in the "C" locale is specified
        by POSIX and should not depend on environment variables like
        by POSIX and should not depend on environment variables like
        "LANGUAGE".  We allow such programs to use gettext().  */
        "LANGUAGE".  We allow such programs to use gettext().  */
  return language != NULL && strcmp (retval, "C") != 0 ? language : retval;
  return language != NULL && strcmp (retval, "C") != 0 ? language : retval;
}
}
 
 
/* @@ begin of epilog @@ */
/* @@ begin of epilog @@ */
 
 
/* We don't want libintl.a to depend on any other library.  So we
/* We don't want libintl.a to depend on any other library.  So we
   avoid the non-standard function stpcpy.  In GNU C Library this
   avoid the non-standard function stpcpy.  In GNU C Library this
   function is available, though.  Also allow the symbol HAVE_STPCPY
   function is available, though.  Also allow the symbol HAVE_STPCPY
   to be defined.  */
   to be defined.  */
#if !_LIBC && !HAVE_STPCPY
#if !_LIBC && !HAVE_STPCPY
static char *
static char *
stpcpy (dest, src)
stpcpy (dest, src)
     char *dest;
     char *dest;
     const char *src;
     const char *src;
{
{
  while ((*dest++ = *src++) != '\0')
  while ((*dest++ = *src++) != '\0')
    /* Do nothing. */ ;
    /* Do nothing. */ ;
  return dest - 1;
  return dest - 1;
}
}
#endif
#endif
 
 
#if !_LIBC && !HAVE_MEMPCPY
#if !_LIBC && !HAVE_MEMPCPY
static void *
static void *
mempcpy (dest, src, n)
mempcpy (dest, src, n)
     void *dest;
     void *dest;
     const void *src;
     const void *src;
     size_t n;
     size_t n;
{
{
  return (void *) ((char *) memcpy (dest, src, n) + n);
  return (void *) ((char *) memcpy (dest, src, n) + n);
}
}
#endif
#endif
 
 
 
 
#ifdef _LIBC
#ifdef _LIBC
/* If we want to free all resources we have to do some work at
/* If we want to free all resources we have to do some work at
   program's end.  */
   program's end.  */
libc_freeres_fn (free_mem)
libc_freeres_fn (free_mem)
{
{
  void *old;
  void *old;
 
 
  while (_nl_domain_bindings != NULL)
  while (_nl_domain_bindings != NULL)
    {
    {
      struct binding *oldp = _nl_domain_bindings;
      struct binding *oldp = _nl_domain_bindings;
      _nl_domain_bindings = _nl_domain_bindings->next;
      _nl_domain_bindings = _nl_domain_bindings->next;
      if (oldp->dirname != INTUSE(_nl_default_dirname))
      if (oldp->dirname != INTUSE(_nl_default_dirname))
        /* Yes, this is a pointer comparison.  */
        /* Yes, this is a pointer comparison.  */
        free (oldp->dirname);
        free (oldp->dirname);
      free (oldp->codeset);
      free (oldp->codeset);
      free (oldp);
      free (oldp);
    }
    }
 
 
  if (_nl_current_default_domain != _nl_default_default_domain)
  if (_nl_current_default_domain != _nl_default_default_domain)
    /* Yes, again a pointer comparison.  */
    /* Yes, again a pointer comparison.  */
    free ((char *) _nl_current_default_domain);
    free ((char *) _nl_current_default_domain);
 
 
  /* Remove the search tree with the known translations.  */
  /* Remove the search tree with the known translations.  */
  __tdestroy (root, free);
  __tdestroy (root, free);
  root = NULL;
  root = NULL;
 
 
  while (transmem_list != NULL)
  while (transmem_list != NULL)
    {
    {
      old = transmem_list;
      old = transmem_list;
      transmem_list = transmem_list->next;
      transmem_list = transmem_list->next;
      free (old);
      free (old);
    }
    }
}
}
#endif
#endif
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.