home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / share / gettext / intl / bindtextdom.c next >
Encoding:
C/C++ Source or Header  |  2006-08-18  |  9.6 KB  |  364 lines
  1. /* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  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
  364.