Back to index

courier  0.68.2
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 "localcharset.h"
#include "gettextP.h"
#include "plural-exp.h"
#include "libgnuintl.h"
#include "hash-string.h"
#include "lock.h"
#include "tsearch.h"
#include "eval-plural.h"
#include "tsearch.c"

Go to the source code of this file.

Classes

struct  known_translation_t
struct  block_list
union  known_translation_t.msgid

Defines

#define _GNU_SOURCE   1
#define __set_errno(val)   errno = (val)
#define alignof(TYPE)   ((int) &((struct { char dummy1; TYPE dummy2; } *) 0)->dummy2)
#define offsetof(type, ident)   ((size_t)&(((type*)0)->ident))
#define getcwd(buf, max)   getwd (buf)
#define tsearch   libintl_tsearch
#define tfind   libintl_tfind
#define tdelete   libintl_tdelete
#define twalk   libintl_twalk
#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 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 void * mempcpy (void *dest, const void *src, size_t n)
 gl_rwlock_define_initialized (static, tree_lock)
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
 gl_rwlock_define_initialized (, _nl_state_lock attribute_hidden) static int enable_secure
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, int convert, 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

Class Documentation

struct known_translation_t

Definition at line 237 of file dcigettext.c.

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

Definition at line 385 of file dcigettext.c.

Collaboration diagram for block_list:
Class Members
void * address
struct block_list * next
union known_translation_t.msgid

Definition at line 266 of file dcigettext.c.

Class Members
char appended
const char * ptr

Define Documentation

#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 _POSIX_PATH_MAX   255

Definition at line 188 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 390 of file dcigettext.c.

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

Definition at line 121 of file dcigettext.c.

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

Definition at line 410 of file dcigettext.c.

Definition at line 435 of file dcigettext.c.

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

Definition at line 461 of file dcigettext.c.

#define ENABLE_SECURE   (enable_secure == 1)

Definition at line 460 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 400 of file dcigettext.c.

#define freea (   p)    free (p)

Definition at line 411 of file dcigettext.c.

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

Definition at line 144 of file dcigettext.c.

#define getegid ( )    getgid()
#define geteuid ( )    getuid()
#define getgid ( )    0
#define getuid ( )    0
#define IS_ABSOLUTE_PATH (   P)    ISSLASH ((P)[0])

Definition at line 226 of file dcigettext.c.

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

Definition at line 227 of file dcigettext.c.

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

Definition at line 225 of file dcigettext.c.

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

Definition at line 127 of file dcigettext.c.

#define PATH_INCR   32

Definition at line 177 of file dcigettext.c.

#define PATH_MAX   _POSIX_PATH_MAX

Definition at line 205 of file dcigettext.c.

#define tdelete   libintl_tdelete

Definition at line 167 of file dcigettext.c.

#define tfind   libintl_tfind

Definition at line 166 of file dcigettext.c.

#define tsearch   libintl_tsearch

Definition at line 165 of file dcigettext.c.

#define twalk   libintl_twalk

Definition at line 168 of file dcigettext.c.


Typedef Documentation

typedef unsigned char transmem_block_t

Definition at line 424 of file dcigettext.c.


Function Documentation

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

Definition at line 888 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
# ifdef IN_LIBGLOCALE
  if (encoding != NULL)
# else
  if (convert)
# endif
    {
      /* We are supposed to do a conversion.  */
# ifndef IN_LIBGLOCALE
      const char *encoding = get_output_charset (domainbinding);
# endif
      size_t nconversions;
      struct converted_domain *convd;
      size_t i;

      /* Protect against reallocation of the table.  */
      gl_rwlock_rdlock (domain->conversions_lock);

      /* Search whether a table with converted translations for this
        encoding has already been allocated.  */
      nconversions = domain->nconversions;
      convd = NULL;

      for (i = nconversions; i > 0; )
       {
         i--;
         if (strcmp (domain->conversions[i].encoding, encoding) == 0)
           {
             convd = &domain->conversions[i];
             break;
           }
       }

      gl_rwlock_unlock (domain->conversions_lock);

      if (convd == NULL)
       {
         /* We have to allocate a new conversions table.  */
         gl_rwlock_wrlock (domain->conversions_lock);
         nconversions = domain->nconversions;

         /* Maybe in the meantime somebody added the translation.
            Recheck.  */
         for (i = nconversions; i > 0; )
           {
             i--;
             if (strcmp (domain->conversions[i].encoding, encoding) == 0)
              {
                convd = &domain->conversions[i];
                goto found_convd;
              }
           }

         {
           /* Allocate a table for the converted translations for this
              encoding.  */
           struct converted_domain *new_conversions =
             (struct converted_domain *)
             (domain->conversions != NULL
              ? realloc (domain->conversions,
                       (nconversions + 1) * sizeof (struct converted_domain))
              : malloc ((nconversions + 1) * sizeof (struct converted_domain)));

           if (__builtin_expect (new_conversions == NULL, 0))
             {
              /* Nothing we can do, no more memory.  We cannot use the
                 translation because it might be encoded incorrectly.  */
             unlock_fail:
              gl_rwlock_unlock (domain->conversions_lock);
              return (char *) -1;
             }

           domain->conversions = new_conversions;

           /* Copy the 'encoding' string to permanent storage.  */
           encoding = strdup (encoding);
           if (__builtin_expect (encoding == NULL, 0))
             /* Nothing we can do, no more memory.  We cannot use the
               translation because it might be encoded incorrectly.  */
             goto unlock_fail;

           convd = &new_conversions[nconversions];
           convd->encoding = encoding;

           /* Find out about the character set the file is encoded with.
              This can be found (in textual form) in the entry "".  If this
              entry does not exist or if this does not contain the 'charset='
              information, we will assume the charset matches the one the
              current locale and we don't have to perform any conversion.  */
# ifdef _LIBC
           convd->conv = (__gconv_t) -1;
# else
#  if HAVE_ICONV
           convd->conv = (iconv_t) -1;
#  endif
# endif
           {
             char *nullentry;
             size_t nullentrylen;

             /* Get the header entry.  This is a recursion, but it doesn't
               reallocate domain->conversions because we pass
               encoding = NULL or convert = 0, respectively.  */
             nullentry =
# ifdef IN_LIBGLOCALE
              _nl_find_msg (domain_file, domainbinding, NULL, "",
                           &nullentrylen);
# else
              _nl_find_msg (domain_file, domainbinding, "", 0, &nullentrylen);
# endif

             if (nullentry != NULL)
              {
                const char *charsetstr;

                charsetstr = strstr (nullentry, "charset=");
                if (charsetstr != NULL)
                  {
                    size_t len;
                    char *charset;
                    const char *outcharset;

                    charsetstr += strlen ("charset=");
                    len = strcspn (charsetstr, " \t\n");

                    charset = (char *) alloca (len + 1);
# if defined _LIBC || HAVE_MEMPCPY
                    *((char *) mempcpy (charset, charsetstr, len)) = '\0';
# else
                    memcpy (charset, charsetstr, len);
                    charset[len] = '\0';
# endif

                    outcharset = encoding;

# ifdef _LIBC
                    /* We always want to use transliteration.  */
                    outcharset = norm_add_slashes (outcharset, "TRANSLIT");
                    charset = norm_add_slashes (charset, "");
                    int r = __gconv_open (outcharset, charset, &convd->conv,
                                       GCONV_AVOID_NOCONV);
                    if (__builtin_expect (r != __GCONV_OK, 0))
                     {
                       /* If the output encoding is the same there is
                          nothing to do.  Otherwise do not use the
                          translation at all.  */
                       if (__builtin_expect (r != __GCONV_NULCONV, 1))
                         {
                           gl_rwlock_unlock (domain->conversions_lock);
                           free ((char *) encoding);
                           return NULL;
                         }

                       convd->conv = (__gconv_t) -1;
                     }
# else
#  if HAVE_ICONV
                    /* When using GNU libc >= 2.2 or GNU libiconv >= 1.5,
                      we want to use transliteration.  */
#   if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2) || __GLIBC__ > 2 \
       || _LIBICONV_VERSION >= 0x0105
                    if (strchr (outcharset, '/') == NULL)
                     {
                       char *tmp;

                       len = strlen (outcharset);
                       tmp = (char *) alloca (len + 10 + 1);
                       memcpy (tmp, outcharset, len);
                       memcpy (tmp + len, "//TRANSLIT", 10 + 1);
                       outcharset = tmp;

                       convd->conv = iconv_open (outcharset, charset);

                       freea (outcharset);
                     }
                    else
#   endif
                     convd->conv = iconv_open (outcharset, charset);
#  endif
# endif

                    freea (charset);
                  }
              }
           }
           convd->conv_tab = NULL;
           /* Here domain->conversions is still == new_conversions.  */
           domain->nconversions++;
         }

       found_convd:
         gl_rwlock_unlock (domain->conversions_lock);
       }

      if (
# ifdef _LIBC
         convd->conv != (__gconv_t) -1
# else
#  if HAVE_ICONV
         convd->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.  */

         /* This lock primarily protects the memory management variables
            freemem, freemem_size.  It also protects write accesses to
            convd->conv_tab.  It's not worth using a separate lock (such
            as domain->conversions_lock) for this purpose, because when
            modifying convd->conv_tab, we also need to lock freemem,
            freemem_size for most of the time.  */
         __libc_lock_define_initialized (static, lock)

         if (__builtin_expect (convd->conv_tab == NULL, 0))
           {
             __libc_lock_lock (lock);
             if (convd->conv_tab == NULL)
              {
                convd->conv_tab =
                  (char **) calloc (nstrings + domain->n_sysdep_strings,
                                  sizeof (char *));
                if (convd->conv_tab != NULL)
                  goto not_translated_yet;
                /* Mark that we didn't succeed allocating a table.  */
                convd->conv_tab = (char **) -1;
              }
             __libc_lock_unlock (lock);
           }

         if (__builtin_expect (convd->conv_tab == (char **) -1, 0))
           /* Nothing we can do, no more memory.  We cannot use the
              translation because it might be encoded incorrectly.  */
           return (char *) -1;

         if (convd->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.   */
# 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;
# endif

             __libc_lock_lock (lock);
           not_translated_yet:

             inbuf = (const unsigned char *) result;
             outbuf = freemem + sizeof (size_t);
# ifndef _LIBC
             transmem_list = NULL;
# endif

             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 (convd->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)
                  {
                    /* We should not use the translation at all, it
                      is incorrectly encoded.  */
                    __libc_lock_unlock (lock);
                    return NULL;
                  }

                inbuf = (const unsigned char *) 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 (convd->conv,
                          (ICONV_CONST char **) &inptr, &inleft,
                          &outptr, &outleft)
                    != (size_t) (-1))
                  {
                    outbuf = (unsigned char *) outptr;
                    break;
                  }
                if (errno != E2BIG)
                  {
                    __libc_lock_unlock (lock);
                    return NULL;
                  }
#  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);
                    return (char *) -1;
                  }

# 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 = (unsigned char *) 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);
             convd->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 convd->conv_tab[act] contains the translation of all
            the plural variants.  */
         result = convd->conv_tab[act] + sizeof (size_t);
         resultlen = *(size_t *) convd->conv_tab[act];
       }
    }

  /* 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 1442 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;
}

Here is the caller graph for this function:

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

Definition at line 487 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;
  const char *dirname;
  char *xdomainname;
  char *single_locale;
  char *retval;
  size_t retlen;
  int saved_errno;
  struct known_translation_t search;
  struct known_translation_t **foundp = NULL;
#if defined HAVE_PER_THREAD_LOCALE && !defined IN_LIBGLOCALE
  const char *localename;
#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

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

#ifdef _LIBC
  __libc_rwlock_define (extern, __libc_setlocale_lock attribute_hidden)
  __libc_rwlock_rdlock (__libc_setlocale_lock);
#endif

  gl_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

  /* Try to find the translation among those which we found at
     some time.  */
  search.domain = NULL;
  search.msgid.ptr = msgid1;
  search.domainname = domainname;
  search.category = category;
#ifdef HAVE_PER_THREAD_LOCALE
# ifndef IN_LIBGLOCALE
#  ifdef _LIBC
  localename = _strdupa (_current_locale_name (category));
#  else
  categoryname = category_to_name (category);
#   define CATEGORYNAME_INITIALIZED
  localename = _nl_locale_name_thread_unsafe (category, categoryname);
  if (localename == NULL)
    localename = "";
#  endif
# endif
  search.localename = localename;
# ifdef IN_LIBGLOCALE
  search.encoding = encoding;
# endif

  /* Since tfind/tsearch manage a balanced tree, concurrent tfind and
     tsearch calls can be fatal.  */
  gl_rwlock_rdlock (tree_lock);

  foundp = (struct known_translation_t **) tfind (&search, &root, transcmp);

  gl_rwlock_unlock (tree_lock);

  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;

      gl_rwlock_unlock (_nl_state_lock);
# ifdef _LIBC
      __libc_rwlock_unlock (__libc_setlocale_lock);
# endif
      __set_errno (saved_errno);
      return retval;
    }
#endif

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

  /* First find matching binding.  */
#ifdef IN_LIBGLOCALE
  /* We can use a trivial binding, since _nl_find_msg will ignore it anyway,
     and _nl_load_domain and _nl_find_domain just pass it through.  */
  binding = NULL;
  dirname = bindtextdomain (domainname, NULL);
#else
  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 = _nl_default_dirname;
  else
    {
      dirname = binding->dirname;
#endif
      if (!IS_ABSOLUTE_PATH (dirname))
       {
         /* We have a relative path.  Make it absolute now.  */
         size_t dirname_len = strlen (dirname) + 1;
         size_t path_max;
         char *resolved_dirname;
         char *ret;

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

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

             __set_errno (0);
             ret = getcwd (resolved_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 (resolved_dirname, '\0'), "/"), dirname);
         dirname = resolved_dirname;
       }
#ifndef IN_LIBGLOCALE
    }
#endif

  /* Now determine the symbolic name of CATEGORY and its value.  */
#ifndef CATEGORYNAME_INITIALIZED
  categoryname = category_to_name (category);
#endif
#ifdef IN_LIBGLOCALE
  categoryvalue = guess_category_value (category, categoryname, localename);
#else
  categoryvalue = guess_category_value (category, categoryname);
#endif

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

  stpcpy ((char *) 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)
       {
#if defined IN_LIBGLOCALE
         retval = _nl_find_msg (domain, binding, encoding, msgid1, &retlen);
#else
         retval = _nl_find_msg (domain, binding, msgid1, 1, &retlen);
#endif

         if (retval == NULL)
           {
             int cnt;

             for (cnt = 0; domain->successor[cnt] != NULL; ++cnt)
              {
#if defined IN_LIBGLOCALE
                retval = _nl_find_msg (domain->successor[cnt], binding,
                                    encoding, msgid1, &retlen);
#else
                retval = _nl_find_msg (domain->successor[cnt], binding,
                                    msgid1, 1, &retlen);
#endif

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

         /* Returning -1 means that some resource problem exists
            (likely memory) and that the strings could not be
            converted.  Return the original strings.  */
         if (__builtin_expect (retval == (char *) -1, 0))
           break;

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

                msgid_len = strlen (msgid1) + 1;
                size = offsetof (struct known_translation_t, msgid)
                      + msgid_len + domainname_len + 1;
#ifdef HAVE_PER_THREAD_LOCALE
                size += strlen (localename) + 1;
#endif
                newp = (struct known_translation_t *) malloc (size);
                if (newp != NULL)
                  {
                    char *new_domainname;
#ifdef HAVE_PER_THREAD_LOCALE
                    char *new_localename;
#endif

                    new_domainname =
                     (char *) mempcpy (newp->msgid.appended, msgid1,
                                     msgid_len);
                    memcpy (new_domainname, domainname, domainname_len + 1);
#ifdef HAVE_PER_THREAD_LOCALE
                    new_localename = new_domainname + domainname_len + 1;
                    strcpy (new_localename, localename);
#endif
                    newp->domainname = new_domainname;
                    newp->category = category;
#ifdef HAVE_PER_THREAD_LOCALE
                    newp->localename = new_localename;
#endif
#ifdef IN_LIBGLOCALE
                    newp->encoding = encoding;
#endif
                    newp->counter = _nl_msg_cat_cntr;
                    newp->domain = domain;
                    newp->translation = retval;
                    newp->translation_length = retlen;

                    gl_rwlock_wrlock (tree_lock);

                    /* Insert the entry in the search tree.  */
                    foundp = (struct known_translation_t **)
                     tsearch (newp, &root, transcmp);

                    gl_rwlock_unlock (tree_lock);

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

             __set_errno (saved_errno);

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

             gl_rwlock_unlock (_nl_state_lock);
#ifdef _LIBC
             __libc_rwlock_unlock (__libc_setlocale_lock);
#endif
             return retval;
           }
       }
    }

 return_untranslated:
  /* Return the untranslated MSGID.  */
  FREE_BLOCKS (block_list);
  gl_rwlock_unlock (_nl_state_lock);
#ifdef _LIBC
  __libc_rwlock_unlock (__libc_setlocale_lock);
#endif
#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 ( )
gl_rwlock_define_initialized ( static  ,
tree_lock   
)

Definition at line 274 of file dcigettext.c.

{
  const struct known_translation_t *s1;
  const struct known_translation_t *s2;
  int result;

  s1 = (const struct known_translation_t *) p1;
  s2 = (const struct known_translation_t *) p2;

  result = strcmp (s1->domain != NULL ? s1->msgid.appended : s1->msgid.ptr,
                 s2->domain != NULL ? s2->msgid.appended : s2->msgid.ptr);
  if (result == 0)
    {
      result = strcmp (s1->domainname, s2->domainname);
      if (result == 0)
       {
#ifdef HAVE_PER_THREAD_LOCALE
         result = strcmp (s1->localename, s2->localename);
         if (result == 0)
#endif
           {
#ifdef IN_LIBGLOCALE
             result = strcmp (s1->encoding, s2->encoding);
             if (result == 0)
#endif
              /* We compare the category last (though this is the cheapest
                 operation) since it is hopefully always the same (namely
                 LC_MESSAGES).  */
              result = s1->category - s2->category;
           }
       }
    }

  return result;
}

Here is the call graph for this function:

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

Definition at line 1508 of file dcigettext.c.

{
  const char *language;
#ifndef IN_LIBGLOCALE
  const char *locale;
# ifndef _LIBC
  const char *language_default;
  int locale_defaulted;
# endif
#endif

  /* We use the settings in the following order:
     1. The value of the environment variable 'LANGUAGE'.  This is a GNU
        extension.  Its value can be a colon-separated list of locale names.
     2. The value of the environment variable 'LC_ALL', 'LC_xxx', or 'LANG'.
        More precisely, the first among these that is set to a non-empty value.
        This is how POSIX specifies it.  The value is a single locale name.
     3. A system-dependent preference list of languages.  Its value can be a
        colon-separated list of locale names.
     4. A system-dependent default locale name.
     This way:
       - System-dependent settings can be overridden by environment variables.
       - If the system provides both a list of languages and a default locale,
         the former is used.  */

#ifndef IN_LIBGLOCALE
  /* Fetch the locale name, through the POSIX method of looking to `LC_ALL',
     `LC_xxx', and `LANG'.  On some systems this can be done by the
     `setlocale' function itself.  */
# ifdef _LIBC
  locale = __current_locale_name (category);
# else
  locale_defaulted = 0;
#  if HAVE_USELOCALE
  locale = _nl_locale_name_thread_unsafe (category, categoryname);
  if (locale == NULL)
#  endif
    {
      locale = _nl_locale_name_posix (category, categoryname);
      if (locale == NULL)
       {
         locale = _nl_locale_name_default ();
         locale_defaulted = 1;
       }
    }
# endif
#endif

  /* Ignore LANGUAGE and its system-dependent analogon 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" or system-dependent information.  We allow such programs
        to use gettext().  */
  if (strcmp (locale, "C") == 0)
    return locale;

  /* The highest priority value is the value of the 'LANGUAGE' environment
     variable.  */
  language = getenv ("LANGUAGE");
  if (language != NULL && language[0] != '\0')
    return language;
#if !defined IN_LIBGLOCALE && !defined _LIBC
  /* The next priority value is the locale name, if not defaulted.  */
  if (locale_defaulted)
    {
      /* The next priority value is the default language preferences list. */
      language_default = _nl_language_preferences_default ();
      if (language_default != NULL)
        return language_default;
    }
  /* The least priority value is the locale name, if defaulted.  */
#endif
  return locale;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 1661 of file dcigettext.c.

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

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 1404 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 1651 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 335 of file dcigettext.c.

Definition at line 344 of file dcigettext.c.

const char* _nl_current_default_domain attribute_hidden = "messages"

Definition at line 319 of file dcigettext.c.

int errno