[deliverable/binutils-gdb.git] / intl / bindtextdom.c

/* Implementation of the bindtextdomain(3) function
   Copyright (C) 1995-1998, 2000, 2001, 2002 Free Software Foundation, Inc.

   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU Library General Public License as published
   by the Free Software Foundation; either version 2, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301,
   USA.  */

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#include <stddef.h>
#include <stdlib.h>
#include <string.h>

#ifdef _LIBC
# include <libintl.h>
#else
# include "libgnuintl.h"
#endif
#include "gettextP.h"

#ifdef _LIBC
/* We have to handle multi-threaded applications.  */
# include <bits/libc-lock.h>
#else
/* Provide dummy implementation if this is outside glibc.  */
# define __libc_rwlock_define(CLASS, NAME)
# define __libc_rwlock_wrlock(NAME)
# define __libc_rwlock_unlock(NAME)
#endif

/* The internal variables in the standalone libintl.a must have different
   names than the internal variables in GNU libc, otherwise programs
   using libintl.a cannot be linked statically.  */
#if !defined _LIBC
# define _nl_default_dirname libintl_nl_default_dirname
# define _nl_domain_bindings libintl_nl_domain_bindings
#endif

/* Some compilers, like SunOS4 cc, don't have offsetof in <stddef.h>.  */
#ifndef offsetof
# define offsetof(type,ident) ((size_t)&(((type*)0)->ident))
#endif

/* @@ end of prolog @@ */

/* Contains the default location of the message catalogs.  */
extern const char _nl_default_dirname[];
#ifdef _LIBC
extern const char _nl_default_dirname_internal[] attribute_hidden;
#else
# define INTUSE(name) name
#endif

/* List with bindings of specific domains.  */
extern struct binding *_nl_domain_bindings;

/* Lock variable to protect the global data in the gettext implementation.  */
__libc_rwlock_define (extern, _nl_state_lock attribute_hidden)


/* 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 BINDTEXTDOMAIN __bindtextdomain
# define BIND_TEXTDOMAIN_CODESET __bind_textdomain_codeset
# ifndef strdup
#  define strdup(str) __strdup (str)
# endif
#else
# define BINDTEXTDOMAIN libintl_bindtextdomain
# define BIND_TEXTDOMAIN_CODESET libintl_bind_textdomain_codeset
#endif

/* Prototypes for local functions.  */
static void set_binding_values PARAMS ((const char *domainname,
					const char **dirnamep,
					const char **codesetp));

/* Specifies the directory name *DIRNAMEP and the output codeset *CODESETP
   to be used for the DOMAINNAME message catalog.
   If *DIRNAMEP or *CODESETP is NULL, the corresponding attribute is not
   modified, only the current value is returned.
   If DIRNAMEP or CODESETP is NULL, the corresponding attribute is neither
   modified nor returned.  */
static void
set_binding_values (domainname, dirnamep, codesetp)
     const char *domainname;
     const char **dirnamep;
     const char **codesetp;
{
  struct binding *binding;
  int modified;

  /* Some sanity checks.  */
  if (domainname == NULL || domainname[0] == '\0')
    {
      if (dirnamep)
	*dirnamep = NULL;
      if (codesetp)
	*codesetp = NULL;
      return;
    }

  __libc_rwlock_wrlock (_nl_state_lock);

  modified = 0;

  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)
    {
      if (dirnamep)
	{
	  const char *dirname = *dirnamep;

	  if (dirname == NULL)
	    /* The current binding has be to returned.  */
	    *dirnamep = binding->dirname;
	  else
	    {
	      /* The domain is already bound.  If the new value and the old
		 one are equal we simply do nothing.  Otherwise replace the
		 old binding.  */
	      char *result = binding->dirname;
	      if (strcmp (dirname, result) != 0)
		{
		  if (strcmp (dirname, INTUSE(_nl_default_dirname)) == 0)
		    result = (char *) INTUSE(_nl_default_dirname);
		  else
		    {
#if defined _LIBC || defined HAVE_STRDUP
		      result = strdup (dirname);
#else
		      size_t len = strlen (dirname) + 1;
		      result = (char *) malloc (len);
		      if (__builtin_expect (result != NULL, 1))
			memcpy (result, dirname, len);
#endif
		    }

		  if (__builtin_expect (result != NULL, 1))
		    {
		      if (binding->dirname != INTUSE(_nl_default_dirname))
			free (binding->dirname);

		      binding->dirname = result;
		      modified = 1;
		    }
		}
	      *dirnamep = result;
	    }
	}

      if (codesetp)
	{
	  const char *codeset = *codesetp;

	  if (codeset == NULL)
	    /* The current binding has be to returned.  */
	    *codesetp = binding->codeset;
	  else
	    {
	      /* The domain is already bound.  If the new value and the old
		 one are equal we simply do nothing.  Otherwise replace the
		 old binding.  */
	      char *result = binding->codeset;
	      if (result == NULL || strcmp (codeset, result) != 0)
		{
#if defined _LIBC || defined HAVE_STRDUP
		  result = strdup (codeset);
#else
		  size_t len = strlen (codeset) + 1;
		  result = (char *) malloc (len);
		  if (__builtin_expect (result != NULL, 1))
		    memcpy (result, codeset, len);
#endif

		  if (__builtin_expect (result != NULL, 1))
		    {
		      if (binding->codeset != NULL)
			free (binding->codeset);

		      binding->codeset = result;
		      binding->codeset_cntr++;
		      modified = 1;
		    }
		}
	      *codesetp = result;
	    }
	}
    }
  else if ((dirnamep == NULL || *dirnamep == NULL)
	   && (codesetp == NULL || *codesetp == NULL))
    {
      /* Simply return the default values.  */
      if (dirnamep)
	*dirnamep = INTUSE(_nl_default_dirname);
      if (codesetp)
	*codesetp = NULL;
    }
  else
    {
      /* We have to create a new binding.  */
      size_t len = strlen (domainname) + 1;
      struct binding *new_binding =
	(struct binding *) malloc (offsetof (struct binding, domainname) + len);

      if (__builtin_expect (new_binding == NULL, 0))
	goto failed;

      memcpy (new_binding->domainname, domainname, len);

      if (dirnamep)
	{
	  const char *dirname = *dirnamep;

	  if (dirname == NULL)
	    /* The default value.  */
	    dirname = INTUSE(_nl_default_dirname);
	  else
	    {
	      if (strcmp (dirname, INTUSE(_nl_default_dirname)) == 0)
		dirname = INTUSE(_nl_default_dirname);
	      else
		{
		  char *result;
#if defined _LIBC || defined HAVE_STRDUP
		  result = strdup (dirname);
		  if (__builtin_expect (result == NULL, 0))
		    goto failed_dirname;
#else
		  size_t len = strlen (dirname) + 1;
		  result = (char *) malloc (len);
		  if (__builtin_expect (result == NULL, 0))
		    goto failed_dirname;
		  memcpy (result, dirname, len);
#endif
		  dirname = result;
		}
	    }
	  *dirnamep = dirname;
	  new_binding->dirname = (char *) dirname;
	}
      else
	/* The default value.  */
	new_binding->dirname = (char *) INTUSE(_nl_default_dirname);

      new_binding->codeset_cntr = 0;

      if (codesetp)
	{
	  const char *codeset = *codesetp;

	  if (codeset != NULL)
	    {
	      char *result;

#if defined _LIBC || defined HAVE_STRDUP
	      result = strdup (codeset);
	      if (__builtin_expect (result == NULL, 0))
		goto failed_codeset;
#else
	      size_t len = strlen (codeset) + 1;
	      result = (char *) malloc (len);
	      if (__builtin_expect (result == NULL, 0))
		goto failed_codeset;
	      memcpy (result, codeset, len);
#endif
	      codeset = result;
	      new_binding->codeset_cntr++;
	    }
	  *codesetp = codeset;
	  new_binding->codeset = (char *) codeset;
	}
      else
	new_binding->codeset = NULL;

      /* Now enqueue it.  */
      if (_nl_domain_bindings == NULL
	  || strcmp (domainname, _nl_domain_bindings->domainname) < 0)
	{
	  new_binding->next = _nl_domain_bindings;
	  _nl_domain_bindings = new_binding;
	}
      else
	{
	  binding = _nl_domain_bindings;
	  while (binding->next != NULL
		 && strcmp (domainname, binding->next->domainname) > 0)
	    binding = binding->next;

	  new_binding->next = binding->next;
	  binding->next = new_binding;
	}

      modified = 1;

      /* Here we deal with memory allocation failures.  */
      if (0)
	{
	failed_codeset:
	  if (new_binding->dirname != INTUSE(_nl_default_dirname))
	    free (new_binding->dirname);
	failed_dirname:
	  free (new_binding);
	failed:
	  if (dirnamep)
	    *dirnamep = NULL;
	  if (codesetp)
	    *codesetp = NULL;
	}
    }

  /* If we modified any binding, we flush the caches.  */
  if (modified)
    ++_nl_msg_cat_cntr;

  __libc_rwlock_unlock (_nl_state_lock);
}

/* Specify that the DOMAINNAME message catalog will be found
   in DIRNAME rather than in the system locale data base.  */
char *
BINDTEXTDOMAIN (domainname, dirname)
     const char *domainname;
     const char *dirname;
{
  set_binding_values (domainname, &dirname, NULL);
  return (char *) dirname;
}

/* Specify the character encoding in which the messages from the
   DOMAINNAME message catalog will be returned.  */
char *
BIND_TEXTDOMAIN_CODESET (domainname, codeset)
     const char *domainname;
     const char *codeset;
{
  set_binding_values (domainname, NULL, &codeset);
  return (char *) codeset;
}

#ifdef _LIBC
/* Aliases for function names in GNU C Library.  */
weak_alias (__bindtextdomain, bindtextdomain);
weak_alias (__bind_textdomain_codeset, bind_textdomain_codeset);
#endif
Commit	Line	Data
252b5132	1	/* Implementation of the bindtextdomain(3) function
bf070c84	2	Copyright (C) 1995-1998, 2000, 2001, 2002 Free Software Foundation, Inc.
252b5132	3
bf070c84 SE	4	This program is free software; you can redistribute it and/or modify it
	5	under the terms of the GNU Library General Public License as published
	6	by the Free Software Foundation; either version 2, or (at your option)
252b5132 RH	7	any later version.
	8
	9	This program is distributed in the hope that it will be useful,
	10	but WITHOUT ANY WARRANTY; without even the implied warranty of
bf070c84 SE	11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
bf070c84 SE	12	Library General Public License for more details.
252b5132	13
bf070c84 SE	14	You should have received a copy of the GNU Library General Public
	15	License along with this program; if not, write to the Free Software
	16	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301,
	17	USA. */
252b5132 RH	18
	19	#ifdef HAVE_CONFIG_H
	20	# include <config.h>
	21	#endif
	22
bf070c84 SE	23	#include <stddef.h>
	24	#include <stdlib.h>
	25	#include <string.h>
252b5132	26
bf070c84 SE	27	#ifdef _LIBC
bf070c84 SE	28	# include <libintl.h>
252b5132	29	#else
bf070c84	30	# include "libgnuintl.h"
252b5132	31	#endif
bf070c84	32	#include "gettextP.h"
252b5132 RH	33
252b5132 RH	34	#ifdef _LIBC
bf070c84 SE	35	/* We have to handle multi-threaded applications. */
bf070c84 SE	36	# include <bits/libc-lock.h>
252b5132	37	#else
bf070c84 SE	38	/* Provide dummy implementation if this is outside glibc. */
	39	# define __libc_rwlock_define(CLASS, NAME)
	40	# define __libc_rwlock_wrlock(NAME)
	41	# define __libc_rwlock_unlock(NAME)
	42	#endif
	43
	44	/* The internal variables in the standalone libintl.a must have different
	45	names than the internal variables in GNU libc, otherwise programs
	46	using libintl.a cannot be linked statically. */
	47	#if !defined _LIBC
	48	# define _nl_default_dirname libintl_nl_default_dirname
	49	# define _nl_domain_bindings libintl_nl_domain_bindings
	50	#endif
	51
	52	/* Some compilers, like SunOS4 cc, don't have offsetof in <stddef.h>. */
	53	#ifndef offsetof
	54	# define offsetof(type,ident) ((size_t)&(((type*)0)->ident))
252b5132	55	#endif
252b5132 RH	56
	57	/* @@ end of prolog @@ */
	58
	59	/* Contains the default location of the message catalogs. */
	60	extern const char _nl_default_dirname[];
bf070c84 SE	61	#ifdef _LIBC
	62	extern const char _nl_default_dirname_internal[] attribute_hidden;
	63	#else
	64	# define INTUSE(name) name
	65	#endif
252b5132 RH	66
	67	/* List with bindings of specific domains. */
	68	extern struct binding *_nl_domain_bindings;
	69
bf070c84 SE	70	/* Lock variable to protect the global data in the gettext implementation. */
	71	__libc_rwlock_define (extern, _nl_state_lock attribute_hidden)
	72
252b5132 RH	73
	74	/* Names for the libintl functions are a problem. They must not clash
	75	with existing names and they should follow ANSI C. But this source
	76	code is also used in GNU C Library where the names have a __
	77	prefix. So we have to make a difference here. */
	78	#ifdef _LIBC
	79	# define BINDTEXTDOMAIN __bindtextdomain
bf070c84	80	# define BIND_TEXTDOMAIN_CODESET __bind_textdomain_codeset
1491f078 BE	81	# ifndef strdup
	82	# define strdup(str) __strdup (str)
	83	# endif
252b5132	84	#else
bf070c84 SE	85	# define BINDTEXTDOMAIN libintl_bindtextdomain
bf070c84 SE	86	# define BIND_TEXTDOMAIN_CODESET libintl_bind_textdomain_codeset
252b5132 RH	87	#endif
252b5132 RH	88
bf070c84 SE	89	/* Prototypes for local functions. */
	90	static void set_binding_values PARAMS ((const char *domainname,
	91	const char **dirnamep,
	92	const char **codesetp));
	93
	94	/* Specifies the directory name DIRNAMEP and the output codeset CODESETP
	95	to be used for the DOMAINNAME message catalog.
	96	If DIRNAMEP or CODESETP is NULL, the corresponding attribute is not
	97	modified, only the current value is returned.
	98	If DIRNAMEP or CODESETP is NULL, the corresponding attribute is neither
	99	modified nor returned. */
	100	static void
	101	set_binding_values (domainname, dirnamep, codesetp)
252b5132	102	const char *domainname;
bf070c84 SE	103	const char **dirnamep;
bf070c84 SE	104	const char **codesetp;
252b5132 RH	105	{
252b5132 RH	106	struct binding *binding;
bf070c84	107	int modified;
252b5132 RH	108
	109	/* Some sanity checks. */
	110	if (domainname == NULL \|\| domainname[0] == '\0')
bf070c84 SE	111	{
	112	if (dirnamep)
	113	*dirnamep = NULL;
	114	if (codesetp)
	115	*codesetp = NULL;
	116	return;
	117	}
	118
	119	__libc_rwlock_wrlock (_nl_state_lock);
	120
	121	modified = 0;
252b5132 RH	122
	123	for (binding = _nl_domain_bindings; binding != NULL; binding = binding->next)
	124	{
	125	int compare = strcmp (domainname, binding->domainname);
	126	if (compare == 0)
	127	/* We found it! */
	128	break;
	129	if (compare < 0)
	130	{
	131	/* It is not in the list. */
	132	binding = NULL;
	133	break;
	134	}
	135	}
	136
252b5132 RH	137	if (binding != NULL)
252b5132 RH	138	{
bf070c84	139	if (dirnamep)
252b5132	140	{
bf070c84	141	const char dirname = dirnamep;
252b5132	142
bf070c84 SE	143	if (dirname == NULL)
	144	/* The current binding has be to returned. */
	145	*dirnamep = binding->dirname;
252b5132 RH	146	else
252b5132 RH	147	{
bf070c84 SE	148	/* The domain is already bound. If the new value and the old
	149	one are equal we simply do nothing. Otherwise replace the
	150	old binding. */
	151	char *result = binding->dirname;
	152	if (strcmp (dirname, result) != 0)
	153	{
	154	if (strcmp (dirname, INTUSE(_nl_default_dirname)) == 0)
	155	result = (char *) INTUSE(_nl_default_dirname);
	156	else
	157	{
252b5132	158	#if defined _LIBC \|\| defined HAVE_STRDUP
bf070c84	159	result = strdup (dirname);
252b5132	160	#else
bf070c84 SE	161	size_t len = strlen (dirname) + 1;
	162	result = (char *) malloc (len);
	163	if (__builtin_expect (result != NULL, 1))
	164	memcpy (result, dirname, len);
252b5132	165	#endif
bf070c84 SE	166	}
	167
	168	if (__builtin_expect (result != NULL, 1))
	169	{
	170	if (binding->dirname != INTUSE(_nl_default_dirname))
	171	free (binding->dirname);
	172
	173	binding->dirname = result;
	174	modified = 1;
	175	}
	176	}
	177	*dirnamep = result;
252b5132	178	}
bf070c84 SE	179	}
	180
	181	if (codesetp)
	182	{
	183	const char codeset = codesetp;
	184
	185	if (codeset == NULL)
	186	/* The current binding has be to returned. */
	187	*codesetp = binding->codeset;
	188	else
	189	{
	190	/* The domain is already bound. If the new value and the old
	191	one are equal we simply do nothing. Otherwise replace the
	192	old binding. */
	193	char *result = binding->codeset;
	194	if (result == NULL \|\| strcmp (codeset, result) != 0)
	195	{
	196	#if defined _LIBC \|\| defined HAVE_STRDUP
	197	result = strdup (codeset);
	198	#else
	199	size_t len = strlen (codeset) + 1;
	200	result = (char *) malloc (len);
	201	if (__builtin_expect (result != NULL, 1))
	202	memcpy (result, codeset, len);
	203	#endif
252b5132	204
bf070c84 SE	205	if (__builtin_expect (result != NULL, 1))
	206	{
	207	if (binding->codeset != NULL)
	208	free (binding->codeset);
252b5132	209
bf070c84 SE	210	binding->codeset = result;
	211	binding->codeset_cntr++;
	212	modified = 1;
	213	}
	214	}
	215	*codesetp = result;
	216	}
252b5132 RH	217	}
252b5132 RH	218	}
bf070c84 SE	219	else if ((dirnamep == NULL \|\| *dirnamep == NULL)
	220	&& (codesetp == NULL \|\| *codesetp == NULL))
	221	{
	222	/* Simply return the default values. */
	223	if (dirnamep)
	224	*dirnamep = INTUSE(_nl_default_dirname);
	225	if (codesetp)
	226	*codesetp = NULL;
	227	}
252b5132 RH	228	else
	229	{
	230	/* We have to create a new binding. */
bf070c84	231	size_t len = strlen (domainname) + 1;
252b5132	232	struct binding *new_binding =
bf070c84 SE	233	(struct binding *) malloc (offsetof (struct binding, domainname) + len);
	234
	235	if (__builtin_expect (new_binding == NULL, 0))
	236	goto failed;
252b5132	237
bf070c84 SE	238	memcpy (new_binding->domainname, domainname, len);
	239
	240	if (dirnamep)
	241	{
	242	const char dirname = dirnamep;
252b5132	243
bf070c84 SE	244	if (dirname == NULL)
	245	/* The default value. */
	246	dirname = INTUSE(_nl_default_dirname);
	247	else
	248	{
	249	if (strcmp (dirname, INTUSE(_nl_default_dirname)) == 0)
	250	dirname = INTUSE(_nl_default_dirname);
	251	else
	252	{
	253	char *result;
252b5132	254	#if defined _LIBC \|\| defined HAVE_STRDUP
bf070c84 SE	255	result = strdup (dirname);
	256	if (__builtin_expect (result == NULL, 0))
	257	goto failed_dirname;
252b5132	258	#else
bf070c84 SE	259	size_t len = strlen (dirname) + 1;
	260	result = (char *) malloc (len);
	261	if (__builtin_expect (result == NULL, 0))
	262	goto failed_dirname;
	263	memcpy (result, dirname, len);
252b5132	264	#endif
bf070c84 SE	265	dirname = result;
	266	}
	267	}
	268	*dirnamep = dirname;
	269	new_binding->dirname = (char *) dirname;
	270	}
252b5132	271	else
bf070c84 SE	272	/* The default value. */
	273	new_binding->dirname = (char *) INTUSE(_nl_default_dirname);
	274
	275	new_binding->codeset_cntr = 0;
	276
	277	if (codesetp)
252b5132	278	{
bf070c84 SE	279	const char codeset = codesetp;
	280
	281	if (codeset != NULL)
	282	{
	283	char *result;
	284
252b5132	285	#if defined _LIBC \|\| defined HAVE_STRDUP
bf070c84 SE	286	result = strdup (codeset);
	287	if (__builtin_expect (result == NULL, 0))
	288	goto failed_codeset;
252b5132	289	#else
bf070c84 SE	290	size_t len = strlen (codeset) + 1;
	291	result = (char *) malloc (len);
	292	if (__builtin_expect (result == NULL, 0))
	293	goto failed_codeset;
	294	memcpy (result, codeset, len);
252b5132	295	#endif
bf070c84 SE	296	codeset = result;
	297	new_binding->codeset_cntr++;
	298	}
	299	*codesetp = codeset;
	300	new_binding->codeset = (char *) codeset;
252b5132	301	}
bf070c84 SE	302	else
bf070c84 SE	303	new_binding->codeset = NULL;
252b5132 RH	304
	305	/* Now enqueue it. */
	306	if (_nl_domain_bindings == NULL
	307	\|\| strcmp (domainname, _nl_domain_bindings->domainname) < 0)
	308	{
	309	new_binding->next = _nl_domain_bindings;
	310	_nl_domain_bindings = new_binding;
	311	}
	312	else
	313	{
	314	binding = _nl_domain_bindings;
	315	while (binding->next != NULL
	316	&& strcmp (domainname, binding->next->domainname) > 0)
	317	binding = binding->next;
	318
	319	new_binding->next = binding->next;
	320	binding->next = new_binding;
	321	}
	322
bf070c84 SE	323	modified = 1;
	324
	325	/* Here we deal with memory allocation failures. */
	326	if (0)
	327	{
	328	failed_codeset:
	329	if (new_binding->dirname != INTUSE(_nl_default_dirname))
	330	free (new_binding->dirname);
	331	failed_dirname:
	332	free (new_binding);
	333	failed:
	334	if (dirnamep)
	335	*dirnamep = NULL;
	336	if (codesetp)
	337	*codesetp = NULL;
	338	}
252b5132 RH	339	}
252b5132 RH	340
bf070c84 SE	341	/* If we modified any binding, we flush the caches. */
	342	if (modified)
	343	++_nl_msg_cat_cntr;
	344
	345	__libc_rwlock_unlock (_nl_state_lock);
	346	}
	347
	348	/* Specify that the DOMAINNAME message catalog will be found
	349	in DIRNAME rather than in the system locale data base. */
	350	char *
	351	BINDTEXTDOMAIN (domainname, dirname)
	352	const char *domainname;
	353	const char *dirname;
	354	{
	355	set_binding_values (domainname, &dirname, NULL);
	356	return (char *) dirname;
	357	}
	358
	359	/* Specify the character encoding in which the messages from the
	360	DOMAINNAME message catalog will be returned. */
	361	char *
	362	BIND_TEXTDOMAIN_CODESET (domainname, codeset)
	363	const char *domainname;
	364	const char *codeset;
	365	{
	366	set_binding_values (domainname, NULL, &codeset);
	367	return (char *) codeset;
252b5132 RH	368	}
	369
	370	#ifdef _LIBC
bf070c84	371	/* Aliases for function names in GNU C Library. */
252b5132	372	weak_alias (__bindtextdomain, bindtextdomain);
bf070c84	373	weak_alias (__bind_textdomain_codeset, bind_textdomain_codeset);
252b5132	374	#endif