Back to index

tetex-bin  3.0
Classes | Defines | Typedefs | Functions | Variables
dcigettext.c File Reference
#include <sys/types.h>
#include <errno.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>
#include <signal.h>
#include "gettextP.h"
#include "plural-exp.h"
#include "libgnuintl.h"
#include "hash-string.h"
#include "eval-plural.h"

Go to the source code of this file.

Classes

struct  known_translation_t
struct  block_list

Defines

#define _GNU_SOURCE   1
#define __set_errno(val)   errno = (val)
#define __libc_lock_define_initialized(CLASS, NAME)
#define __libc_lock_lock(NAME)
#define __libc_lock_unlock(NAME)
#define __libc_rwlock_define_initialized(CLASS, NAME)
#define __libc_rwlock_rdlock(NAME)
#define __libc_rwlock_unlock(NAME)
#define alignof(TYPE)   ((int) &((struct { char dummy1; TYPE dummy2; } *) 0)->dummy2)
#define _nl_default_default_domain   libintl_nl_default_default_domain
#define _nl_current_default_domain   libintl_nl_current_default_domain
#define _nl_default_dirname   libintl_nl_default_dirname
#define _nl_domain_bindings   libintl_nl_domain_bindings
#define offsetof(type, ident)   ((size_t)&(((type*)0)->ident))
#define getcwd(buf, max)   getwd (buf)
#define PATH_INCR   32
#define _POSIX_PATH_MAX   255
#define PATH_MAX   _POSIX_PATH_MAX
#define ISSLASH(C)   ((C) == '/')
#define IS_ABSOLUTE_PATH(P)   ISSLASH ((P)[0])
#define IS_PATH_WITH_DIR(P)   (strchr (P, '/') != NULL)
#define INTVARDEF(name)
#define INTUSE(name)   name
#define ADD_BLOCK(list, addr)
#define FREE_BLOCKS(list)
#define alloca(size)   (malloc (size))
#define freea(p)   free (p)
#define DCIGETTEXT   libintl_dcigettext
#define getuid()   0
#define getgid()   0
#define geteuid()   getuid()
#define getegid()   getgid()
#define ENABLE_SECURE   (enable_secure == 1)
#define DETERMINE_SECURE

Typedefs

typedef unsigned char transmem_block_t

Functions

char * alloca ()
char * getwd ()
static char * stpcpy (char *dest, const char *src)
static voidmempcpy (void *dest, const void *src, size_t n)
static char * plural_lookup (struct loaded_l10nfile *domain, unsigned long int n, const char *translation, size_t translation_len) internal_function
static const char * guess_category_value (int category, const char *categoryname) internal_function
static const char * category_to_name (int category) internal_function
char * DCIGETTEXT (const char *domainname, const char *msgid1, const char *msgid2, int plural, unsigned long int n, int category)
char *internal_function _nl_find_msg (struct loaded_l10nfile *domain_file, struct binding *domainbinding, const char *msgid, size_t *lengthp)

Variables

int errno
const char
_nl_default_default_domain[] 
attribute_hidden = "messages"
const char _nl_default_dirname [] = LOCALEDIR
struct binding_nl_domain_bindings
static int enable_secure

Class Documentation

struct known_translation_t

Definition at line 221 of file dcigettext.c.

Collaboration diagram for known_translation_t:
Class Members
int category
int counter
struct loaded_l10nfile * domain
char * domainname
char msgid
const char * translation
size_t translation_length
struct block_list

Definition at line 331 of file dcigettext.c.

Collaboration diagram for block_list:
Class Members
void * address
struct block_list * next

Define Documentation

#define __libc_lock_define_initialized (   CLASS,
  NAME 
)

Definition at line 104 of file dcigettext.c.

#define __libc_lock_lock (   NAME)

Definition at line 105 of file dcigettext.c.

#define __libc_lock_unlock (   NAME)

Definition at line 106 of file dcigettext.c.

#define __libc_rwlock_define_initialized (   CLASS,
  NAME 
)

Definition at line 107 of file dcigettext.c.

#define __libc_rwlock_rdlock (   NAME)

Definition at line 108 of file dcigettext.c.

#define __libc_rwlock_unlock (   NAME)

Definition at line 109 of file dcigettext.c.

#define __set_errno (   val)    errno = (val)

Definition at line 59 of file dcigettext.c.

#define _GNU_SOURCE   1

Definition at line 23 of file dcigettext.c.

#define _nl_current_default_domain   libintl_nl_current_default_domain

Definition at line 125 of file dcigettext.c.

#define _nl_default_default_domain   libintl_nl_default_default_domain

Definition at line 124 of file dcigettext.c.

Definition at line 126 of file dcigettext.c.

#define _nl_domain_bindings   libintl_nl_domain_bindings

Definition at line 127 of file dcigettext.c.

#define _POSIX_PATH_MAX   255

Definition at line 177 of file dcigettext.c.

#define ADD_BLOCK (   list,
  addr 
)
Value:
do {                                                                 \
    struct block_list *newp = (struct block_list *) malloc (sizeof (*newp));  \
    /* If we cannot get a free block we cannot add the new element to       \
       the list.  */                                                 \
    if (newp != NULL) {                                                     \
      newp->address = (addr);                                               \
      newp->next = (list);                                           \
      (list) = newp;                                                 \
    }                                                                \
  } while (0)

Definition at line 336 of file dcigettext.c.

#define alignof (   TYPE)    ((int) &((struct { char dummy1; TYPE dummy2; } *) 0)->dummy2)

Definition at line 116 of file dcigettext.c.

#define alloca (   size)    (malloc (size))

Definition at line 356 of file dcigettext.c.

Definition at line 381 of file dcigettext.c.

Value:
if (enable_secure == 0)                                              \
    {                                                                \
      if (getuid () != geteuid () || getgid () != getegid ())               \
       enable_secure = 1;                                            \
      else                                                           \
       enable_secure = -1;                                           \
    }

Definition at line 409 of file dcigettext.c.

#define ENABLE_SECURE   (enable_secure == 1)

Definition at line 408 of file dcigettext.c.

#define FREE_BLOCKS (   list)
Value:
do {                                                                 \
    while (list != NULL) {                                           \
      struct block_list *old = list;                                        \
      list = list->next;                                             \
      free (old->address);                                           \
      free (old);                                                    \
    }                                                                \
  } while (0)

Definition at line 346 of file dcigettext.c.

#define freea (   p)    free (p)

Definition at line 357 of file dcigettext.c.

#define getcwd (   buf,
  max 
)    getwd (buf)

Definition at line 149 of file dcigettext.c.

#define getegid ( )    getgid()

Definition at line 405 of file dcigettext.c.

#define geteuid ( )    getuid()

Definition at line 402 of file dcigettext.c.

#define getgid ( )    0

Definition at line 399 of file dcigettext.c.

#define getuid ( )    0

Definition at line 396 of file dcigettext.c.

#define INTUSE (   name)    name

Definition at line 284 of file dcigettext.c.

#define INTVARDEF (   name)

Definition at line 281 of file dcigettext.c.

#define IS_ABSOLUTE_PATH (   P)    ISSLASH ((P)[0])

Definition at line 215 of file dcigettext.c.

#define IS_PATH_WITH_DIR (   P)    (strchr (P, '/') != NULL)

Definition at line 216 of file dcigettext.c.

#define ISSLASH (   C)    ((C) == '/')

Definition at line 214 of file dcigettext.c.

#define offsetof (   type,
  ident 
)    ((size_t)&(((type*)0)->ident))

Definition at line 132 of file dcigettext.c.

#define PATH_INCR   32

Definition at line 166 of file dcigettext.c.

#define PATH_MAX   _POSIX_PATH_MAX

Definition at line 194 of file dcigettext.c.


Typedef Documentation

typedef unsigned char transmem_block_t

Definition at line 370 of file dcigettext.c.


Function Documentation

char* internal_function _nl_find_msg ( struct loaded_l10nfile domain_file,
struct binding domainbinding,
const char *  msgid,
size_t lengthp 
)

Definition at line 721 of file dcigettext.c.

{
  struct loaded_domain *domain;
  nls_uint32 nstrings;
  size_t act;
  char *result;
  size_t resultlen;

  if (domain_file->decided == 0)
    _nl_load_domain (domain_file, domainbinding);

  if (domain_file->data == NULL)
    return NULL;

  domain = (struct loaded_domain *) domain_file->data;

  nstrings = domain->nstrings;

  /* Locate the MSGID and its translation.  */
  if (domain->hash_tab != NULL)
    {
      /* Use the hashing table.  */
      nls_uint32 len = strlen (msgid);
      nls_uint32 hash_val = hash_string (msgid);
      nls_uint32 idx = hash_val % domain->hash_size;
      nls_uint32 incr = 1 + (hash_val % (domain->hash_size - 2));

      while (1)
       {
         nls_uint32 nstr =
           W (domain->must_swap_hash_tab, domain->hash_tab[idx]);

         if (nstr == 0)
           /* Hash table entry is empty.  */
           return NULL;

         nstr--;

         /* Compare msgid with the original string at index nstr.
            We compare the lengths with >=, not ==, because plural entries
            are represented by strings with an embedded NUL.  */
         if (nstr < nstrings
             ? W (domain->must_swap, domain->orig_tab[nstr].length) >= len
              && (strcmp (msgid,
                         domain->data + W (domain->must_swap,
                                         domain->orig_tab[nstr].offset))
                  == 0)
             : domain->orig_sysdep_tab[nstr - nstrings].length > len
              && (strcmp (msgid,
                         domain->orig_sysdep_tab[nstr - nstrings].pointer)
                  == 0))
           {
             act = nstr;
             goto found;
           }

         if (idx >= domain->hash_size - incr)
           idx -= domain->hash_size - incr;
         else
           idx += incr;
       }
      /* NOTREACHED */
    }
  else
    {
      /* Try the default method:  binary search in the sorted array of
        messages.  */
      size_t top, bottom;

      bottom = 0;
      top = nstrings;
      while (bottom < top)
       {
         int cmp_val;

         act = (bottom + top) / 2;
         cmp_val = strcmp (msgid, (domain->data
                                + W (domain->must_swap,
                                    domain->orig_tab[act].offset)));
         if (cmp_val < 0)
           top = act;
         else if (cmp_val > 0)
           bottom = act + 1;
         else
           goto found;
       }
      /* No translation was found.  */
      return NULL;
    }

 found:
  /* The translation was found at index ACT.  If we have to convert the
     string to use a different character set, this is the time.  */
  if (act < nstrings)
    {
      result = (char *)
       (domain->data + W (domain->must_swap, domain->trans_tab[act].offset));
      resultlen = W (domain->must_swap, domain->trans_tab[act].length) + 1;
    }
  else
    {
      result = (char *) domain->trans_sysdep_tab[act - nstrings].pointer;
      resultlen = domain->trans_sysdep_tab[act - nstrings].length;
    }

#if defined _LIBC || HAVE_ICONV
  if (domain->codeset_cntr
      != (domainbinding != NULL ? domainbinding->codeset_cntr : 0))
    {
      /* The domain's codeset has changed through bind_textdomain_codeset()
        since the message catalog was initialized or last accessed.  We
        have to reinitialize the converter.  */
      _nl_free_domain_conv (domain);
      _nl_init_domain_conv (domain_file, domain, domainbinding);
    }

  if (
# ifdef _LIBC
      domain->conv != (__gconv_t) -1
# else
#  if HAVE_ICONV
      domain->conv != (iconv_t) -1
#  endif
# endif
      )
    {
      /* We are supposed to do a conversion.  First allocate an
        appropriate table with the same structure as the table
        of translations in the file, where we can put the pointers
        to the converted strings in.
        There is a slight complication with plural entries.  They
        are represented by consecutive NUL terminated strings.  We
        handle this case by converting RESULTLEN bytes, including
        NULs.  */

      if (domain->conv_tab == NULL
         && ((domain->conv_tab =
               (char **) calloc (nstrings + domain->n_sysdep_strings,
                               sizeof (char *)))
             == NULL))
       /* Mark that we didn't succeed allocating a table.  */
       domain->conv_tab = (char **) -1;

      if (__builtin_expect (domain->conv_tab == (char **) -1, 0))
       /* Nothing we can do, no more memory.  */
       goto converted;

      if (domain->conv_tab[act] == NULL)
       {
         /* We haven't used this string so far, so it is not
            translated yet.  Do this now.  */
         /* We use a bit more efficient memory handling.
            We allocate always larger blocks which get used over
            time.  This is faster than many small allocations.   */
         __libc_lock_define_initialized (static, lock)
# define INITIAL_BLOCK_SIZE 4080
         static unsigned char *freemem;
         static size_t freemem_size;

         const unsigned char *inbuf;
         unsigned char *outbuf;
         int malloc_count;
# ifndef _LIBC
         transmem_block_t *transmem_list = NULL;
# endif

         __libc_lock_lock (lock);

         inbuf = (const unsigned char *) result;
         outbuf = freemem + sizeof (size_t);

         malloc_count = 0;
         while (1)
           {
             transmem_block_t *newmem;
# ifdef _LIBC
             size_t non_reversible;
             int res;

             if (freemem_size < sizeof (size_t))
              goto resize_freemem;

             res = __gconv (domain->conv,
                          &inbuf, inbuf + resultlen,
                          &outbuf,
                          outbuf + freemem_size - sizeof (size_t),
                          &non_reversible);

             if (res == __GCONV_OK || res == __GCONV_EMPTY_INPUT)
              break;

             if (res != __GCONV_FULL_OUTPUT)
              {
                __libc_lock_unlock (lock);
                goto converted;
              }

             inbuf = result;
# else
#  if HAVE_ICONV
             const char *inptr = (const char *) inbuf;
             size_t inleft = resultlen;
             char *outptr = (char *) outbuf;
             size_t outleft;

             if (freemem_size < sizeof (size_t))
              goto resize_freemem;

             outleft = freemem_size - sizeof (size_t);
             if (iconv (domain->conv,
                      (ICONV_CONST char **) &inptr, &inleft,
                      &outptr, &outleft)
                != (size_t) (-1))
              {
                outbuf = (unsigned char *) outptr;
                break;
              }
             if (errno != E2BIG)
              {
                __libc_lock_unlock (lock);
                goto converted;
              }
#  endif
# endif

           resize_freemem:
             /* We must allocate a new buffer or resize the old one.  */
             if (malloc_count > 0)
              {
                ++malloc_count;
                freemem_size = malloc_count * INITIAL_BLOCK_SIZE;
                newmem = (transmem_block_t *) realloc (transmem_list,
                                                  freemem_size);
# ifdef _LIBC
                if (newmem != NULL)
                  transmem_list = transmem_list->next;
                else
                  {
                    struct transmem_list *old = transmem_list;

                    transmem_list = transmem_list->next;
                    free (old);
                  }
# endif
              }
             else
              {
                malloc_count = 1;
                freemem_size = INITIAL_BLOCK_SIZE;
                newmem = (transmem_block_t *) malloc (freemem_size);
              }
             if (__builtin_expect (newmem == NULL, 0))
              {
                freemem = NULL;
                freemem_size = 0;
                __libc_lock_unlock (lock);
                goto converted;
              }

# ifdef _LIBC
             /* Add the block to the list of blocks we have to free
                 at some point.  */
             newmem->next = transmem_list;
             transmem_list = newmem;

             freemem = newmem->data;
             freemem_size -= offsetof (struct transmem_list, data);
# else
             transmem_list = newmem;
             freemem = newmem;
# endif

             outbuf = freemem + sizeof (size_t);
           }

         /* We have now in our buffer a converted string.  Put this
            into the table of conversions.  */
         *(size_t *) freemem = outbuf - freemem - sizeof (size_t);
         domain->conv_tab[act] = (char *) freemem;
         /* Shrink freemem, but keep it aligned.  */
         freemem_size -= outbuf - freemem;
         freemem = outbuf;
         freemem += freemem_size & (alignof (size_t) - 1);
         freemem_size = freemem_size & ~ (alignof (size_t) - 1);

         __libc_lock_unlock (lock);
       }

      /* Now domain->conv_tab[act] contains the translation of all
        the plural variants.  */
      result = domain->conv_tab[act] + sizeof (size_t);
      resultlen = *(size_t *) domain->conv_tab[act];
    }

 converted:
  /* The result string is converted.  */

#endif /* _LIBC || HAVE_ICONV */

  *lengthp = resultlen;
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* alloca ( )
static const char *internal_function category_to_name ( int  category) [static]

Definition at line 1068 of file dcigettext.c.

{
  const char *retval;

  switch (category)
  {
#ifdef LC_COLLATE
  case LC_COLLATE:
    retval = "LC_COLLATE";
    break;
#endif
#ifdef LC_CTYPE
  case LC_CTYPE:
    retval = "LC_CTYPE";
    break;
#endif
#ifdef LC_MONETARY
  case LC_MONETARY:
    retval = "LC_MONETARY";
    break;
#endif
#ifdef LC_NUMERIC
  case LC_NUMERIC:
    retval = "LC_NUMERIC";
    break;
#endif
#ifdef LC_TIME
  case LC_TIME:
    retval = "LC_TIME";
    break;
#endif
#ifdef LC_MESSAGES
  case LC_MESSAGES:
    retval = "LC_MESSAGES";
    break;
#endif
#ifdef LC_RESPONSE
  case LC_RESPONSE:
    retval = "LC_RESPONSE";
    break;
#endif
#ifdef LC_ALL
  case LC_ALL:
    /* This might not make sense but is perhaps better than any other
       value.  */
    retval = "LC_ALL";
    break;
#endif
  default:
    /* If you have a better idea for a default value let me know.  */
    retval = "LC_XXX";
  }

  return retval;
}
char* DCIGETTEXT ( const char *  domainname,
const char *  msgid1,
const char *  msgid2,
int  plural,
unsigned long int  n,
int  category 
)

Definition at line 427 of file dcigettext.c.

{
#ifndef HAVE_ALLOCA
  struct block_list *block_list = NULL;
#endif
  struct loaded_l10nfile *domain;
  struct binding *binding;
  const char *categoryname;
  const char *categoryvalue;
  char *dirname, *xdomainname;
  char *single_locale;
  char *retval;
  size_t retlen;
  int saved_errno;
#if defined HAVE_TSEARCH || defined _LIBC
  struct known_translation_t *search;
  struct known_translation_t **foundp = NULL;
  size_t msgid_len;
#endif
  size_t domainname_len;

  /* If no real MSGID is given return NULL.  */
  if (msgid1 == NULL)
    return NULL;

#ifdef _LIBC
  if (category < 0 || category >= __LC_LAST || category == LC_ALL)
    /* Bogus.  */
    return (plural == 0
           ? (char *) msgid1
           /* Use the Germanic plural rule.  */
           : n == 1 ? (char *) msgid1 : (char *) msgid2);
#endif

  __libc_rwlock_rdlock (_nl_state_lock);

  /* 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
     definition left this undefined.  */
  if (domainname == NULL)
    domainname = _nl_current_default_domain;

  /* OS/2 specific: backward compatibility with older libintl versions  */
#ifdef LC_MESSAGES_COMPAT
  if (category == LC_MESSAGES_COMPAT)
    category = LC_MESSAGES;
#endif

#if defined HAVE_TSEARCH || defined _LIBC
  msgid_len = strlen (msgid1) + 1;

  /* Try to find the translation among those which we found at
     some time.  */
  search = (struct known_translation_t *)
          alloca (offsetof (struct known_translation_t, msgid) + msgid_len);
  memcpy (search->msgid, msgid1, msgid_len);
  search->domainname = (char *) domainname;
  search->category = category;

  foundp = (struct known_translation_t **) tfind (search, &root, transcmp);
  freea (search);
  if (foundp != NULL && (*foundp)->counter == _nl_msg_cat_cntr)
    {
      /* Now deal with plural.  */
      if (plural)
       retval = plural_lookup ((*foundp)->domain, n, (*foundp)->translation,
                            (*foundp)->translation_length);
      else
       retval = (char *) (*foundp)->translation;

      __libc_rwlock_unlock (_nl_state_lock);
      return retval;
    }
#endif

  /* Preserve the `errno' value.  */
  saved_errno = errno;

  /* See whether this is a SUID binary or not.  */
  DETERMINE_SECURE;

  /* First find matching binding.  */
  for (binding = _nl_domain_bindings; binding != NULL; binding = binding->next)
    {
      int compare = strcmp (domainname, binding->domainname);
      if (compare == 0)
       /* We found it!  */
       break;
      if (compare < 0)
       {
         /* It is not in the list.  */
         binding = NULL;
         break;
       }
    }

  if (binding == NULL)
    dirname = (char *) INTUSE(_nl_default_dirname);
  else if (IS_ABSOLUTE_PATH (binding->dirname))
    dirname = binding->dirname;
  else
    {
      /* We have a relative path.  Make it absolute now.  */
      size_t dirname_len = strlen (binding->dirname) + 1;
      size_t path_max;
      char *ret;

      path_max = (unsigned int) PATH_MAX;
      path_max += 2;        /* The getcwd docs say to do this.  */

      for (;;)
       {
         dirname = (char *) alloca (path_max + dirname_len);
         ADD_BLOCK (block_list, dirname);

         __set_errno (0);
         ret = getcwd (dirname, path_max);
         if (ret != NULL || errno != ERANGE)
           break;

         path_max += path_max / 2;
         path_max += PATH_INCR;
       }

      if (ret == NULL)
       /* We cannot get the current working directory.  Don't signal an
          error but simply return the default string.  */
       goto return_untranslated;

      stpcpy (stpcpy (strchr (dirname, '\0'), "/"), binding->dirname);
    }

  /* Now determine the symbolic name of CATEGORY and its value.  */
  categoryname = category_to_name (category);
  categoryvalue = guess_category_value (category, categoryname);

  domainname_len = strlen (domainname);
  xdomainname = (char *) alloca (strlen (categoryname)
                             + domainname_len + 5);
  ADD_BLOCK (block_list, xdomainname);

  stpcpy (mempcpy (stpcpy (stpcpy (xdomainname, categoryname), "/"),
                domainname, domainname_len),
         ".mo");

  /* Creating working area.  */
  single_locale = (char *) alloca (strlen (categoryvalue) + 1);
  ADD_BLOCK (block_list, single_locale);


  /* Search for the given string.  This is a loop because we perhaps
     got an ordered list of languages to consider for the translation.  */
  while (1)
    {
      /* Make CATEGORYVALUE point to the next element of the list.  */
      while (categoryvalue[0] != '\0' && categoryvalue[0] == ':')
       ++categoryvalue;
      if (categoryvalue[0] == '\0')
       {
         /* The whole contents of CATEGORYVALUE has been searched but
            no valid entry has been found.  We solve this situation
            by implicitly appending a "C" entry, i.e. no translation
            will take place.  */
         single_locale[0] = 'C';
         single_locale[1] = '\0';
       }
      else
       {
         char *cp = single_locale;
         while (categoryvalue[0] != '\0' && categoryvalue[0] != ':')
           *cp++ = *categoryvalue++;
         *cp = '\0';

         /* When this is a SUID binary we must not allow accessing files
            outside the dedicated directories.  */
         if (ENABLE_SECURE && IS_PATH_WITH_DIR (single_locale))
           /* Ingore this entry.  */
           continue;
       }

      /* If the current locale value is C (or POSIX) we don't load a
        domain.  Return the MSGID.  */
      if (strcmp (single_locale, "C") == 0
         || strcmp (single_locale, "POSIX") == 0)
       break;

      /* Find structure describing the message catalog matching the
        DOMAINNAME and CATEGORY.  */
      domain = _nl_find_domain (dirname, single_locale, xdomainname, binding);

      if (domain != NULL)
       {
         retval = _nl_find_msg (domain, binding, msgid1, &retlen);

         if (retval == NULL)
           {
             int cnt;

             for (cnt = 0; domain->successor[cnt] != NULL; ++cnt)
              {
                retval = _nl_find_msg (domain->successor[cnt], binding,
                                    msgid1, &retlen);

                if (retval != NULL)
                  {
                    domain = domain->successor[cnt];
                    break;
                  }
              }
           }

         if (retval != NULL)
           {
             /* Found the translation of MSGID1 in domain DOMAIN:
               starting at RETVAL, RETLEN bytes.  */
             FREE_BLOCKS (block_list);
#if defined HAVE_TSEARCH || defined _LIBC
             if (foundp == NULL)
              {
                /* Create a new entry and add it to the search tree.  */
                struct known_translation_t *newp;

                newp = (struct known_translation_t *)
                  malloc (offsetof (struct known_translation_t, msgid)
                         + msgid_len + domainname_len + 1);
                if (newp != NULL)
                  {
                    newp->domainname =
                     mempcpy (newp->msgid, msgid1, msgid_len);
                    memcpy (newp->domainname, domainname, domainname_len + 1);
                    newp->category = category;
                    newp->counter = _nl_msg_cat_cntr;
                    newp->domain = domain;
                    newp->translation = retval;
                    newp->translation_length = retlen;

                    /* Insert the entry in the search tree.  */
                    foundp = (struct known_translation_t **)
                     tsearch (newp, &root, transcmp);
                    if (foundp == NULL
                       || __builtin_expect (*foundp != newp, 0))
                     /* The insert failed.  */
                     free (newp);
                  }
              }
             else
              {
                /* We can update the existing entry.  */
                (*foundp)->counter = _nl_msg_cat_cntr;
                (*foundp)->domain = domain;
                (*foundp)->translation = retval;
                (*foundp)->translation_length = retlen;
              }
#endif
             __set_errno (saved_errno);

             /* Now deal with plural.  */
             if (plural)
              retval = plural_lookup (domain, n, retval, retlen);

             __libc_rwlock_unlock (_nl_state_lock);
             return retval;
           }
       }
    }

 return_untranslated:
  /* Return the untranslated MSGID.  */
  FREE_BLOCKS (block_list);
  __libc_rwlock_unlock (_nl_state_lock);
#ifndef _LIBC
  if (!ENABLE_SECURE)
    {
      extern void _nl_log_untranslated (const char *logfilename,
                                   const char *domainname,
                                   const char *msgid1, const char *msgid2,
                                   int plural);
      const char *logfilename = getenv ("GETTEXT_LOG_UNTRANSLATED");

      if (logfilename != NULL && logfilename[0] != '\0')
       _nl_log_untranslated (logfilename, domainname, msgid1, msgid2, plural);
    }
#endif
  __set_errno (saved_errno);
  return (plural == 0
         ? (char *) msgid1
         /* Use the Germanic plural rule.  */
         : n == 1 ? (char *) msgid1 : (char *) msgid2);
}

Here is the call graph for this function:

char* getwd ( )

Here is the caller graph for this function:

static const char *internal_function guess_category_value ( int  category,
const char *  categoryname 
) [static]

Definition at line 1128 of file dcigettext.c.

{
  const char *language;
  const char *retval;

  /* The highest priority value is the `LANGUAGE' environment
     variable.  But we don't use the value if the currently selected
     locale is the C locale.  This is a GNU extension.  */
  language = getenv ("LANGUAGE");
  if (language != NULL && language[0] == '\0')
    language = NULL;

  /* 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
     `setlocale' function itself.  */
#ifdef _LIBC
  retval = __current_locale_name (category);
#else
  retval = _nl_locale_name (category, categoryname);
#endif

  /* Ignore LANGUAGE if the locale is set to "C" because
     1. "C" locale usually uses the ASCII encoding, and most international
       messages use non-ASCII characters. These characters get displayed
       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 to ASCII). In any case, the output is ugly.
     2. The precise output of some programs in the "C" locale is specified
       by POSIX and should not depend on environment variables like
       "LANGUAGE".  We allow such programs to use gettext().  */
  return language != NULL && strcmp (retval, "C") != 0 ? language : retval;
}

Here is the call graph for this function:

static void * mempcpy ( void dest,
const void src,
size_t  n 
) [static]

Definition at line 1179 of file dcigettext.c.

{
  return (void *) ((char *) memcpy (dest, src, n) + n);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char *internal_function plural_lookup ( struct loaded_l10nfile domain,
unsigned long int  n,
const char *  translation,
size_t  translation_len 
) [static]

Definition at line 1030 of file dcigettext.c.

{
  struct loaded_domain *domaindata = (struct loaded_domain *) domain->data;
  unsigned long int index;
  const char *p;

  index = plural_eval (domaindata->plural, n);
  if (index >= domaindata->nplurals)
    /* This should never happen.  It means the plural expression and the
       given maximum value do not match.  */
    index = 0;

  /* Skip INDEX strings at TRANSLATION.  */
  p = translation;
  while (index-- > 0)
    {
#ifdef _LIBC
      p = __rawmemchr (p, '\0');
#else
      p = strchr (p, '\0');
#endif
      /* And skip over the NUL byte.  */
      p++;

      if (p >= translation + translation_len)
       /* This should never happen.  It means the plural expression
          evaluated to a value larger than the number of variants
          available for MSGID1.  */
       return (char *) translation;
    }
  return (char *) p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char * stpcpy ( char *  dest,
const char *  src 
) [static]

Definition at line 1169 of file dcigettext.c.

{
  while ((*dest++ = *src++) != '\0')
    /* Do nothing. */ ;
  return dest - 1;
}

Here is the caller graph for this function:


Variable Documentation

Definition at line 299 of file dcigettext.c.

Definition at line 305 of file dcigettext.c.

Definition at line 289 of file dcigettext.c.

int enable_secure [static]

Definition at line 407 of file dcigettext.c.