[thirdparty/gcc.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
0c104362	1	/* Implementation of the bindtextdomain(3) function
1e12d536	2	Copyright (C) 1995-1998, 2000, 2001, 2002 Free Software Foundation, Inc.
0c104362	3
778fc1c8	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)
0c104362	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
778fc1c8	11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
778fc1c8	12	Library General Public License for more details.
0c104362	13
778fc1c8	14	You should have received a copy of the GNU Library General Public
778fc1c8	15	License along with this program; if not, write to the Free Software
729b154c	16	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301,
778fc1c8	17	USA. */
0c104362	18
	19	#ifdef HAVE_CONFIG_H
	20	# include <config.h>
	21	#endif
	22
778fc1c8	23	#include <stddef.h>
	24	#include <stdlib.h>
	25	#include <string.h>
0c104362	26
778fc1c8	27	#ifdef _LIBC
778fc1c8	28	# include <libintl.h>
0c104362	29	#else
778fc1c8	30	# include "libgnuintl.h"
0c104362	31	#endif
778fc1c8	32	#include "gettextP.h"
0c104362	33
0c104362	34	#ifdef _LIBC
778fc1c8	35	/* We have to handle multi-threaded applications. */
778fc1c8	36	# include <bits/libc-lock.h>
0c104362	37	#else
778fc1c8	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)
0c104362	42	#endif
0c104362	43
67c50934	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
1e12d536	48	# define _nl_default_dirname libintl_nl_default_dirname
1e12d536	49	# define _nl_domain_bindings libintl_nl_domain_bindings
67c50934	50	#endif
67c50934	51
778fc1c8	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))
	55	#endif
	56
0c104362	57	/* @@ end of prolog @@ */
	58
	59	/* Contains the default location of the message catalogs. */
	60	extern const char _nl_default_dirname[];
1e12d536	61	#ifdef _LIBC
	62	extern const char _nl_default_dirname_internal[] attribute_hidden;
	63	#else
	64	# define INTUSE(name) name
	65	#endif
0c104362	66
	67	/* List with bindings of specific domains. */
	68	extern struct binding *_nl_domain_bindings;
	69
778fc1c8	70	/* Lock variable to protect the global data in the gettext implementation. */
1e12d536	71	__libc_rwlock_define (extern, _nl_state_lock attribute_hidden)
778fc1c8	72
0c104362	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
778fc1c8	80	# define BIND_TEXTDOMAIN_CODESET __bind_textdomain_codeset
0c104362	81	# ifndef strdup
	82	# define strdup(str) __strdup (str)
	83	# endif
	84	#else
1e12d536	85	# define BINDTEXTDOMAIN libintl_bindtextdomain
1e12d536	86	# define BIND_TEXTDOMAIN_CODESET libintl_bind_textdomain_codeset
0c104362	87	#endif
0c104362	88
778fc1c8	89	/* Prototypes for local functions. */
	90	static void set_binding_values PARAMS ((const char *domainname,
	91	const char **dirnamep,
	92	const char **codesetp));
1e12d536	93
778fc1c8	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)
0c104362	102	const char *domainname;
778fc1c8	103	const char **dirnamep;
778fc1c8	104	const char **codesetp;
0c104362	105	{
0c104362	106	struct binding *binding;
778fc1c8	107	int modified;
0c104362	108
	109	/* Some sanity checks. */
	110	if (domainname == NULL \|\| domainname[0] == '\0')
778fc1c8	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;
0c104362	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
0c104362	137	if (binding != NULL)
0c104362	138	{
778fc1c8	139	if (dirnamep)
0c104362	140	{
778fc1c8	141	const char dirname = dirnamep;
0c104362	142
778fc1c8	143	if (dirname == NULL)
	144	/* The current binding has be to returned. */
	145	*dirnamep = binding->dirname;
0c104362	146	else
0c104362	147	{
778fc1c8	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	{
1e12d536	154	if (strcmp (dirname, INTUSE(_nl_default_dirname)) == 0)
1e12d536	155	result = (char *) INTUSE(_nl_default_dirname);
778fc1c8	156	else
778fc1c8	157	{
0c104362	158	#if defined _LIBC \|\| defined HAVE_STRDUP
778fc1c8	159	result = strdup (dirname);
0c104362	160	#else
778fc1c8	161	size_t len = strlen (dirname) + 1;
	162	result = (char *) malloc (len);
	163	if (__builtin_expect (result != NULL, 1))
	164	memcpy (result, dirname, len);
0c104362	165	#endif
778fc1c8	166	}
	167
	168	if (__builtin_expect (result != NULL, 1))
	169	{
1e12d536	170	if (binding->dirname != INTUSE(_nl_default_dirname))
778fc1c8	171	free (binding->dirname);
	172
	173	binding->dirname = result;
	174	modified = 1;
	175	}
	176	}
	177	*dirnamep = result;
0c104362	178	}
778fc1c8	179	}
0c104362	180
778fc1c8	181	if (codesetp)
	182	{
	183	const char codeset = codesetp;
0c104362	184
778fc1c8	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
	204
	205	if (__builtin_expect (result != NULL, 1))
	206	{
	207	if (binding->codeset != NULL)
	208	free (binding->codeset);
	209
	210	binding->codeset = result;
	211	binding->codeset_cntr++;
	212	modified = 1;
	213	}
	214	}
	215	*codesetp = result;
	216	}
0c104362	217	}
0c104362	218	}
778fc1c8	219	else if ((dirnamep == NULL \|\| *dirnamep == NULL)
	220	&& (codesetp == NULL \|\| *codesetp == NULL))
	221	{
	222	/* Simply return the default values. */
	223	if (dirnamep)
1e12d536	224	*dirnamep = INTUSE(_nl_default_dirname);
778fc1c8	225	if (codesetp)
	226	*codesetp = NULL;
	227	}
0c104362	228	else
	229	{
	230	/* We have to create a new binding. */
778fc1c8	231	size_t len = strlen (domainname) + 1;
0c104362	232	struct binding *new_binding =
778fc1c8	233	(struct binding *) malloc (offsetof (struct binding, domainname) + len);
0c104362	234
778fc1c8	235	if (__builtin_expect (new_binding == NULL, 0))
778fc1c8	236	goto failed;
0c104362	237
778fc1c8	238	memcpy (new_binding->domainname, domainname, len);
	239
	240	if (dirnamep)
	241	{
	242	const char dirname = dirnamep;
	243
	244	if (dirname == NULL)
	245	/* The default value. */
1e12d536	246	dirname = INTUSE(_nl_default_dirname);
778fc1c8	247	else
778fc1c8	248	{
1e12d536	249	if (strcmp (dirname, INTUSE(_nl_default_dirname)) == 0)
1e12d536	250	dirname = INTUSE(_nl_default_dirname);
778fc1c8	251	else
	252	{
	253	char *result;
0c104362	254	#if defined _LIBC \|\| defined HAVE_STRDUP
778fc1c8	255	result = strdup (dirname);
	256	if (__builtin_expect (result == NULL, 0))
	257	goto failed_dirname;
0c104362	258	#else
778fc1c8	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);
0c104362	264	#endif
778fc1c8	265	dirname = result;
	266	}
	267	}
	268	*dirnamep = dirname;
	269	new_binding->dirname = (char *) dirname;
	270	}
0c104362	271	else
778fc1c8	272	/* The default value. */
1e12d536	273	new_binding->dirname = (char *) INTUSE(_nl_default_dirname);
778fc1c8	274
	275	new_binding->codeset_cntr = 0;
	276
	277	if (codesetp)
0c104362	278	{
778fc1c8	279	const char codeset = codesetp;
	280
	281	if (codeset != NULL)
	282	{
	283	char *result;
	284
0c104362	285	#if defined _LIBC \|\| defined HAVE_STRDUP
778fc1c8	286	result = strdup (codeset);
	287	if (__builtin_expect (result == NULL, 0))
	288	goto failed_codeset;
0c104362	289	#else
778fc1c8	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);
0c104362	295	#endif
778fc1c8	296	codeset = result;
	297	new_binding->codeset_cntr++;
	298	}
	299	*codesetp = codeset;
	300	new_binding->codeset = (char *) codeset;
0c104362	301	}
778fc1c8	302	else
778fc1c8	303	new_binding->codeset = NULL;
0c104362	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
778fc1c8	323	modified = 1;
	324
	325	/* Here we deal with memory allocation failures. */
	326	if (0)
	327	{
	328	failed_codeset:
1e12d536	329	if (new_binding->dirname != INTUSE(_nl_default_dirname))
778fc1c8	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	}
0c104362	339	}
0c104362	340
778fc1c8	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;
0c104362	368	}
	369
	370	#ifdef _LIBC
778fc1c8	371	/* Aliases for function names in GNU C Library. */
0c104362	372	weak_alias (__bindtextdomain, bindtextdomain);
778fc1c8	373	weak_alias (__bind_textdomain_codeset, bind_textdomain_codeset);
0c104362	374	#endif