navit/intl/bindtextdom.c

/* Implementation of the bindtextdomain(3) function
   Copyright (C) 1995-1998, 2000-2003 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
   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

/* 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 (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 (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 (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
1	zoff99	2	/* Implementation of the bindtextdomain(3) function
2			Copyright (C) 1995-1998, 2000-2003 Free Software Foundation, Inc.
3
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)
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
11			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12			Library General Public License for more details.
13
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
17			USA. */
18
19			#ifdef HAVE_CONFIG_H
20			# include <config.h>
21			#endif
22
23			#include <stddef.h>
24			#include <stdlib.h>
25			#include <string.h>
26
27			#ifdef _LIBC
28			# include <libintl.h>
29			#else
30			# include "libgnuintl.h"
31			#endif
32			#include "gettextP.h"
33
34			#ifdef _LIBC
35			/* We have to handle multi-threaded applications. */
36			# include <bits/libc-lock.h>
37			#else
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))
55			#endif
56
57			/* @@ end of prolog @@ */
58
59			/* Contains the default location of the message catalogs. */
60			extern const char _nl_default_dirname[];
61			#ifdef _LIBC
62			extern const char _nl_default_dirname_internal[] attribute_hidden;
63			#else
64			# define INTUSE(name) name
65			#endif
66
67			/* List with bindings of specific domains. */
68			extern struct binding *_nl_domain_bindings;
69
70			/* Lock variable to protect the global data in the gettext implementation. */
71			__libc_rwlock_define (extern, _nl_state_lock attribute_hidden)
72
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
80			# define BIND_TEXTDOMAIN_CODESET __bind_textdomain_codeset
81			# ifndef strdup
82			# define strdup(str) __strdup (str)
83			# endif
84			#else
85			# define BINDTEXTDOMAIN libintl_bindtextdomain
86			# define BIND_TEXTDOMAIN_CODESET libintl_bind_textdomain_codeset
87			#endif
88
89			/* Specifies the directory name DIRNAMEP and the output codeset CODESETP
90			to be used for the DOMAINNAME message catalog.
91			If DIRNAMEP or CODESETP is NULL, the corresponding attribute is not
92			modified, only the current value is returned.
93			If DIRNAMEP or CODESETP is NULL, the corresponding attribute is neither
94			modified nor returned. */
95			static void
96			set_binding_values (const char *domainname,
97			const char dirnamep, const char codesetp)
98			{
99			struct binding *binding;
100			int modified;
101
102			/* Some sanity checks. */
103			if (domainname == NULL \|\| domainname[0] == '\0')
104			{
105			if (dirnamep)
106			*dirnamep = NULL;
107			if (codesetp)
108			*codesetp = NULL;
109			return;
110			}
111
112			__libc_rwlock_wrlock (_nl_state_lock);
113
114			modified = 0;
115
116			for (binding = _nl_domain_bindings; binding != NULL; binding = binding->next)
117			{
118			int compare = strcmp (domainname, binding->domainname);
119			if (compare == 0)
120			/* We found it! */
121			break;
122			if (compare < 0)
123			{
124			/* It is not in the list. */
125			binding = NULL;
126			break;
127			}
128			}
129
130			if (binding != NULL)
131			{
132			if (dirnamep)
133			{
134			const char dirname = dirnamep;
135
136			if (dirname == NULL)
137			/* The current binding has be to returned. */
138			*dirnamep = binding->dirname;
139			else
140			{
141			/* The domain is already bound. If the new value and the old
142			one are equal we simply do nothing. Otherwise replace the
143			old binding. */
144			char *result = binding->dirname;
145			if (strcmp (dirname, result) != 0)
146			{
147			if (strcmp (dirname, INTUSE(_nl_default_dirname)) == 0)
148			result = (char *) INTUSE(_nl_default_dirname);
149			else
150			{
151			#if defined _LIBC \|\| defined HAVE_STRDUP
152			result = strdup (dirname);
153			#else
154			size_t len = strlen (dirname) + 1;
155			result = (char *) malloc (len);
156			if (__builtin_expect (result != NULL, 1))
157			memcpy (result, dirname, len);
158			#endif
159			}
160
161			if (__builtin_expect (result != NULL, 1))
162			{
163			if (binding->dirname != INTUSE(_nl_default_dirname))
164			free (binding->dirname);
165
166			binding->dirname = result;
167			modified = 1;
168			}
169			}
170			*dirnamep = result;
171			}
172			}
173
174			if (codesetp)
175			{
176			const char codeset = codesetp;
177
178			if (codeset == NULL)
179			/* The current binding has be to returned. */
180			*codesetp = binding->codeset;
181			else
182			{
183			/* The domain is already bound. If the new value and the old
184			one are equal we simply do nothing. Otherwise replace the
185			old binding. */
186			char *result = binding->codeset;
187			if (result == NULL \|\| strcmp (codeset, result) != 0)
188			{
189			#if defined _LIBC \|\| defined HAVE_STRDUP
190			result = strdup (codeset);
191			#else
192			size_t len = strlen (codeset) + 1;
193			result = (char *) malloc (len);
194			if (__builtin_expect (result != NULL, 1))
195			memcpy (result, codeset, len);
196			#endif
197
198			if (__builtin_expect (result != NULL, 1))
199			{
200			if (binding->codeset != NULL)
201			free (binding->codeset);
202
203			binding->codeset = result;
204			binding->codeset_cntr++;
205			modified = 1;
206			}
207			}
208			*codesetp = result;
209			}
210			}
211			}
212			else if ((dirnamep == NULL \|\| *dirnamep == NULL)
213			&& (codesetp == NULL \|\| *codesetp == NULL))
214			{
215			/* Simply return the default values. */
216			if (dirnamep)
217			*dirnamep = INTUSE(_nl_default_dirname);
218			if (codesetp)
219			*codesetp = NULL;
220			}
221			else
222			{
223			/* We have to create a new binding. */
224			size_t len = strlen (domainname) + 1;
225			struct binding *new_binding =
226			(struct binding *) malloc (offsetof (struct binding, domainname) + len);
227
228			if (__builtin_expect (new_binding == NULL, 0))
229			goto failed;
230
231			memcpy (new_binding->domainname, domainname, len);
232
233			if (dirnamep)
234			{
235			const char dirname = dirnamep;
236
237			if (dirname == NULL)
238			/* The default value. */
239			dirname = INTUSE(_nl_default_dirname);
240			else
241			{
242			if (strcmp (dirname, INTUSE(_nl_default_dirname)) == 0)
243			dirname = INTUSE(_nl_default_dirname);
244			else
245			{
246			char *result;
247			#if defined _LIBC \|\| defined HAVE_STRDUP
248			result = strdup (dirname);
249			if (__builtin_expect (result == NULL, 0))
250			goto failed_dirname;
251			#else
252			size_t len = strlen (dirname) + 1;
253			result = (char *) malloc (len);
254			if (__builtin_expect (result == NULL, 0))
255			goto failed_dirname;
256			memcpy (result, dirname, len);
257			#endif
258			dirname = result;
259			}
260			}
261			*dirnamep = dirname;
262			new_binding->dirname = (char *) dirname;
263			}
264			else
265			/* The default value. */
266			new_binding->dirname = (char *) INTUSE(_nl_default_dirname);
267
268			new_binding->codeset_cntr = 0;
269
270			if (codesetp)
271			{
272			const char codeset = codesetp;
273
274			if (codeset != NULL)
275			{
276			char *result;
277
278			#if defined _LIBC \|\| defined HAVE_STRDUP
279			result = strdup (codeset);
280			if (__builtin_expect (result == NULL, 0))
281			goto failed_codeset;
282			#else
283			size_t len = strlen (codeset) + 1;
284			result = (char *) malloc (len);
285			if (__builtin_expect (result == NULL, 0))
286			goto failed_codeset;
287			memcpy (result, codeset, len);
288			#endif
289			codeset = result;
290			new_binding->codeset_cntr++;
291			}
292			*codesetp = codeset;
293			new_binding->codeset = (char *) codeset;
294			}
295			else
296			new_binding->codeset = NULL;
297
298			/* Now enqueue it. */
299			if (_nl_domain_bindings == NULL
300			\|\| strcmp (domainname, _nl_domain_bindings->domainname) < 0)
301			{
302			new_binding->next = _nl_domain_bindings;
303			_nl_domain_bindings = new_binding;
304			}
305			else
306			{
307			binding = _nl_domain_bindings;
308			while (binding->next != NULL
309			&& strcmp (domainname, binding->next->domainname) > 0)
310			binding = binding->next;
311
312			new_binding->next = binding->next;
313			binding->next = new_binding;
314			}
315
316			modified = 1;
317
318			/* Here we deal with memory allocation failures. */
319			if (0)
320			{
321			failed_codeset:
322			if (new_binding->dirname != INTUSE(_nl_default_dirname))
323			free (new_binding->dirname);
324			failed_dirname:
325			free (new_binding);
326			failed:
327			if (dirnamep)
328			*dirnamep = NULL;
329			if (codesetp)
330			*codesetp = NULL;
331			}
332			}
333
334			/* If we modified any binding, we flush the caches. */
335			if (modified)
336			++_nl_msg_cat_cntr;
337
338			__libc_rwlock_unlock (_nl_state_lock);
339			}
340
341			/* Specify that the DOMAINNAME message catalog will be found
342			in DIRNAME rather than in the system locale data base. */
343			char *
344			BINDTEXTDOMAIN (const char domainname, const char dirname)
345			{
346			set_binding_values (domainname, &dirname, NULL);
347			return (char *) dirname;
348			}
349
350			/* Specify the character encoding in which the messages from the
351			DOMAINNAME message catalog will be returned. */
352			char *
353			BIND_TEXTDOMAIN_CODESET (const char domainname, const char codeset)
354			{
355			set_binding_values (domainname, NULL, &codeset);
356			return (char *) codeset;
357			}
358
359			#ifdef _LIBC
360			/* Aliases for function names in GNU C Library. */
361			weak_alias (__bindtextdomain, bindtextdomain);
362			weak_alias (__bind_textdomain_codeset, bind_textdomain_codeset);
363			#endif