retval = getenv ("LC_ALL"); if (retval == NULL || retval[0] == '\0') {  retval = getenv (categoryname); if (retval == NULL || retval[0] == '\0') {  retval = getenv ("LANG"); if (retval == NULL || retval[0] == '\0')  return "C"; } }
retval = _nl_locale_name (category, categoryname);
static const char *guess_category_value PARAMS ((int category,						 const char *categoryname))     internal_function;/* For those loosing systems which don't have `alloca' we have to add   some additional code emulating it.  */#ifdef HAVE_ALLOCA/* Nothing has to be done.  */# define ADD_BLOCK(list, address) /* nothing */# define FREE_BLOCKS(list) /* nothing */#elsestruct block_list{  void *address;  struct block_list *next;};# define ADD_BLOCK(list, addr)						      \  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)# define FREE_BLOCKS(list)						      \  do {									      \    while (list != NULL) {						      \      struct block_list *old = list;					      \      list = list->next;						      \      free (old);							      \    }									      \  } while (0)# undef alloca# define alloca(size) (malloc (size))#endif	/* have alloca */#ifdef _LIBC/* List of blocks allocated for translations.  */typedef struct transmem_list{  struct transmem_list *next;  char data[ZERO];} transmem_block_t;static struct transmem_list *transmem_list;#elsetypedef unsigned char transmem_block_t;#endif/* Names for the libintl functions are a problem.  They must not clash   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 __   prefix.  So we have to make a difference here.  */#ifdef _LIBC# define DCIGETTEXT __dcigettext#else# define DCIGETTEXT dcigettext__#endif/* Lock variable to protect the global data in the gettext implementation.  */#ifdef _LIBC__libc_rwlock_define_initialized (, _nl_state_lock)#endif/* Checking whether the binaries runs SUID must be done and glibc provides   easier methods therefore we make a difference here.  */#ifdef _LIBC# define ENABLE_SECURE __libc_enable_secure# define DETERMINE_SECURE#else# ifndef HAVE_GETUID#  define getuid() 0# endif# ifndef HAVE_GETGID#  define getgid() 0# endif# ifndef HAVE_GETEUID#  define geteuid() getuid()# endif# ifndef HAVE_GETEGID#  define getegid() getgid()# endifstatic int enable_secure;# define ENABLE_SECURE (enable_secure == 1)# define DETERMINE_SECURE \  if (enable_secure == 0)						      \    {									      \      if (getuid () != geteuid () || getgid () != getegid ())		      \	enable_secure = 1;						      \      else								      \	enable_secure = -1;						      \    }#endif/* Look up MSGID in the DOMAINNAME message catalog for the current   CATEGORY locale and, if PLURAL is nonzero, search over string   depending on the plural form determined by N.  */char *DCIGETTEXT (domainname, msgid1, msgid2, plural, n, category)     const char *domainname;     const char *msgid1;     const char *msgid2;     int plural;     unsigned long int n;     int category;{#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;  __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;#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);  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 *) _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.  */	  FREE_BLOCKS (block_list);	  __libc_rwlock_unlock (_nl_state_lock);	  __set_errno (saved_errno);	  return (plural == 0		  ? (char *) msgid1		  /* Use the Germanic plural rule.  */		  : n == 1 ? (char *) msgid1 : (char *) msgid2);	}      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)	{	  FREE_BLOCKS (block_list);	  __libc_rwlock_unlock (_nl_state_lock);	  __set_errno (saved_errno);	  return (plural == 0		  ? (char *) msgid1		  /* Use the Germanic plural rule.  */		  : n == 1 ? (char *) msgid1 : (char *) msgid2);	}      /* 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);	      __set_errno (saved_errno);#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	      /* Now deal with plural.  */	      if (plural)		retval = plural_lookup (domain, n, retval, retlen);	      __libc_rwlock_unlock (_nl_state_lock);	      return retval;	    }	}    }  /* NOTREACHED */}char *internal_function_nl_find_msg (domain_file, domainbinding, msgid, lengthp)     struct loaded_l10nfile *domain_file;     struct binding *domainbinding;     const char *msgid;     size_t *lengthp;{  struct loaded_domain *domain;  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;  /* Locate the MSGID and its translation.  */  if (domain->hash_size > 2 && 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, domain->hash_tab[idx]);	  if (nstr == 0)	    /* Hash table entry is empty.  */	    return NULL;	  /* Compare msgid with the original string at index nstr-1.	     We compare the lengths with >=, not ==, because plural entries	     are represented by strings with an embedded NUL.  */	  if (W (domain->must_swap, domain->orig_tab[nstr - 1].length) >= len	      && (strcmp (msgid,			  domain->data + W (domain->must_swap,					    domain->orig_tab[nstr - 1].offset))		  == 0))	    {	      act = nstr - 1;	      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 = domain->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.  */  result = ((char *) domain->data	    + W (domain->must_swap, domain->trans_tab[act].offset));  resultlen = W (domain->must_swap, domain->trans_tab[act].length) + 1;#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 (domain->nstrings,						    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;}/* Look up a plural variant.  */static char *internal_functionplural_lookup (domain, n, translation, translation_len)     struct loaded_l10nfile *domain;     unsigned long int n;     const char *translation;     size_t translation_len;{  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;}/* Function to evaluate the plural expression and return an index value.  */static unsigned long intinternal_functionplural_eval (pexp, n)     struct expression *pexp;     unsigned long int n;{  switch (pexp->nargs)    {    case 0:      switch (pexp->operation)	{	case var:	  return n;	case num:	  return pexp->val.num;	default:	  break;	}      /* NOTREACHED */      break;    case 1:      {	/* pexp->operation must be lnot.  */	unsigned long int arg = plural_eval (pexp->val.args[0], n);	return ! arg;      }    case 2:      {	unsigned long int leftarg = plural_eval (pexp->val.args[0], n);	if (pexp->operation == lor)	  return leftarg || plural_eval (pexp->val.args[1], n);	else if (pexp->operation == land)	  return leftarg && plural_eval (pexp->val.args[1], n);	else	  {	    unsigned long int rightarg = plural_eval (pexp->val.args[1], n);	    switch (pexp->operation)	      {	      case mult:		return leftarg * rightarg;	      case divide:		return leftarg / rightarg;	      case module:		return leftarg % rightarg;	      case plus:		return leftarg + rightarg;	      case minus:		return leftarg - rightarg;	      case less_than:		return leftarg < rightarg;	      case greater_than:		return leftarg > rightarg;	      case less_or_equal:		return leftarg <= rightarg;	      case greater_or_equal:		return leftarg >= rightarg;	      case equal:		return leftarg == rightarg;	      case not_equal:		return leftarg != rightarg;	      default:		break;	      }	  }	/* NOTREACHED */	break;      }    case 3:      {	/* pexp->operation must be qmop.  */	unsigned long int boolarg = plural_eval (pexp->val.args[0], n);	return plural_eval (pexp->val.args[boolarg ? 1 : 2], n);      }    }  /* NOTREACHED */  return 0;}/* Return string representation of locale CATEGORY.  */static const char *internal_functioncategory_to_name (category)     int category;{  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;}/* Guess value of current locale from value of the environment variables.  */static const char *internal_functionguess_category_value (category, categoryname)     int category;     const char *categoryname;{  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.  */#if defined _LIBC || (defined HAVE_SETLOCALE && defined HAVE_LC_MESSAGES && defined HAVE_LOCALE_NULL)  retval = setlocale (category, NULL);#else  /* Setting of LC_ALL overwrites all other.  */  retval = getenv ("LC_ALL");  if (retval == NULL || retval[0] == '\0')    {      /* Next comes the name of the desired category.  */      retval = getenv (categoryname);      if (retval == NULL || retval[0] == '\0')	{	  /* Last possibility is the LANG environment variable.  */	  retval = getenv ("LANG");	  if (retval == NULL || retval[0] == '\0')	    /* We use C as the default domain.  POSIX says this is	       implementation defined.  */	    return "C";	}    }#endif  return language != NULL && strcmp (retval, "C") != 0 ? language : retval;}