Use __tolower_l, __isdigit_l, __isspace_l with _nl_C_locobj instead of
[kopensolaris-gnu/glibc.git] / iconv / gconv_open.c
1 /* Find matching transformation algorithms and initialize steps.
2    Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
5
6    The GNU C Library is free software; you can redistribute it and/or
7    modify it under the terms of the GNU Lesser General Public
8    License as published by the Free Software Foundation; either
9    version 2.1 of the License, or (at your option) any later version.
10
11    The GNU C Library is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14    Lesser General Public License for more details.
15
16    You should have received a copy of the GNU Lesser General Public
17    License along with the GNU C Library; if not, write to the Free
18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19    02111-1307 USA.  */
20
21 #include <errno.h>
22 #include <locale.h>
23 #include <stdlib.h>
24 #include <string.h>
25
26 #include <gconv_int.h>
27
28
29 int
30 internal_function
31 __gconv_open (const char *toset, const char *fromset, __gconv_t *handle,
32               int flags)
33 {
34   struct __gconv_step *steps;
35   size_t nsteps;
36   __gconv_t result = NULL;
37   size_t cnt = 0;
38   int res;
39   int conv_flags = 0;
40   const char *errhand;
41   const char *ignore;
42   struct trans_struct *trans = NULL;
43
44   /* Find out whether any error handling method is specified.  */
45   errhand = strchr (toset, '/');
46   if (errhand != NULL)
47     errhand = strchr (errhand + 1, '/');
48   if (__builtin_expect (errhand != NULL, 1))
49     {
50       if (*++errhand == '\0')
51         errhand = NULL;
52       else
53         {
54           /* Make copy without the error handling description.  */
55           char *newtoset = (char *) alloca (errhand - toset + 1);
56           char *tok;
57           char *ptr;
58
59           newtoset[errhand - toset] = '\0';
60           toset = memcpy (newtoset, toset, errhand - toset);
61
62           /* Find the appropriate transliteration handlers.  */
63           tok = strdupa (errhand);
64
65           tok = __strtok_r (tok, ",", &ptr);
66           while (tok != NULL)
67             {
68               if (__strcasecmp_l (tok, "TRANSLIT", &_nl_C_locobj) == 0)
69                 {
70                   /* It's the builtin transliteration handling.  We only
71                      support it for working on the internal encoding.  */
72                   static const char *internal_trans_names[1] = { "INTERNAL" };
73                   struct trans_struct *lastp = NULL;
74                   struct trans_struct *runp;
75
76                   for (runp = trans; runp != NULL; runp = runp->next)
77                     if (runp->trans_fct == __gconv_transliterate)
78                       break;
79                     else
80                       lastp = runp;
81
82                   if (runp == NULL)
83                     {
84                       struct trans_struct *newp;
85
86                       newp = (struct trans_struct *) alloca (sizeof (*newp));
87                       memset (newp, '\0', sizeof (*newp));
88
89                       /* We leave the `name' field zero to signal that
90                          this is an internal transliteration step.  */
91                       newp->csnames = internal_trans_names;
92                       newp->ncsnames = 1;
93                       newp->trans_fct = __gconv_transliterate;
94
95                       if (lastp == NULL)
96                         trans = newp;
97                       else
98                         lastp->next = newp;
99                     }
100                 }
101               else if (__strcasecmp_l (tok, "IGNORE", &_nl_C_locobj) == 0)
102                 /* Set the flag to ignore all errors.  */
103                 conv_flags |= __GCONV_IGNORE_ERRORS;
104               else
105                 {
106                   /* `tok' is possibly a module name.  We'll see later
107                      whether we can find it.  But first see that we do
108                      not already a module of this name.  */
109                   struct trans_struct *lastp = NULL;
110                   struct trans_struct *runp;
111
112                   for (runp = trans; runp != NULL; runp = runp->next)
113                     if (runp->name != NULL
114                         && __strcasecmp_l (tok, runp->name,
115                                            &_nl_C_locobj) == 0)
116                       break;
117                     else
118                       lastp = runp;
119
120                   if (runp == NULL)
121                     {
122                       struct trans_struct *newp;
123
124                       newp = (struct trans_struct *) alloca (sizeof (*newp));
125                       memset (newp, '\0', sizeof (*newp));
126                       newp->name = tok;
127
128                       if (lastp == NULL)
129                         trans = newp;
130                       else
131                         lastp->next = newp;
132                     }
133                 }
134
135               tok = __strtok_r (NULL, ",", &ptr);
136             }
137         }
138     }
139
140   /* For the source character set we ignore the error handler specification.
141      XXX Is this really always the best?  */
142   ignore = strchr (fromset, '/');
143   if (ignore != NULL && (ignore = strchr (ignore + 1, '/')) != NULL
144       && *++ignore != '\0')
145     {
146       char *newfromset = (char *) alloca (ignore - fromset + 1);
147
148       newfromset[ignore - fromset] = '\0';
149       fromset = memcpy (newfromset, fromset, ignore - fromset);
150     }
151
152   res = __gconv_find_transform (toset, fromset, &steps, &nsteps, flags);
153   if (res == __GCONV_OK)
154     {
155       /* Find the modules.  */
156       struct trans_struct *lastp = NULL;
157       struct trans_struct *runp;
158
159       for (runp = trans; runp != NULL; runp = runp->next)
160         {
161           if (runp->name == NULL
162               || __builtin_expect (__gconv_translit_find (runp), 0) == 0)
163             lastp = runp;
164           else
165             /* This means we haven't found the module.  Remove it.  */
166             (lastp == NULL ? trans : lastp->next) = runp->next;
167         }
168
169       /* Allocate room for handle.  */
170       result = (__gconv_t) malloc (sizeof (struct __gconv_info)
171                                    + (nsteps
172                                       * sizeof (struct __gconv_step_data)));
173       if (result == NULL)
174         res = __GCONV_NOMEM;
175       else
176         {
177           size_t n;
178
179           /* Remember the list of steps.  */
180           result->__steps = steps;
181           result->__nsteps = nsteps;
182
183           /* Clear the array for the step data.  */
184           memset (result->__data, '\0',
185                   nsteps * sizeof (struct __gconv_step_data));
186
187           /* Call all initialization functions for the transformation
188              step implementations.  */
189           for (cnt = 0; cnt < nsteps; ++cnt)
190             {
191               size_t size;
192
193               /* Would have to be done if we would not clear the whole
194                  array above.  */
195 #if 0
196               /* Reset the counter.  */
197               result->__data[cnt].__invocation_counter = 0;
198
199               /* It's a regular use.  */
200               result->__data[cnt].__internal_use = 0;
201 #endif
202
203               /* We use the `mbstate_t' member in DATA.  */
204               result->__data[cnt].__statep = &result->__data[cnt].__state;
205
206               /* Now see whether we can use any of the transliteration
207                  modules for this step.  */
208               for (runp = trans; runp != NULL; runp = runp->next)
209                 for (n = 0; n < runp->ncsnames; ++n)
210                   if (__strcasecmp_l (steps[cnt].__from_name,
211                                       runp->csnames[n], &_nl_C_locobj) == 0)
212                     {
213                       void *data = NULL;
214
215                       /* Match!  Now try the initializer.  */
216                       if (runp->trans_init_fct == NULL
217                           || (runp->trans_init_fct (&data,
218                                                     steps[cnt].__to_name)
219                               == __GCONV_OK))
220                         {
221                           /* Append at the end of the list.  */
222                           struct __gconv_trans_data *newp;
223                           struct __gconv_trans_data **lastp;
224
225                           newp = (struct __gconv_trans_data *)
226                             malloc (sizeof (struct __gconv_trans_data));
227                           if (newp == NULL)
228                             {
229                               res = __GCONV_NOMEM;
230                               goto bail;
231                             }
232
233                           newp->__trans_fct = runp->trans_fct;
234                           newp->__trans_context_fct = runp->trans_context_fct;
235                           newp->__trans_end_fct = runp->trans_end_fct;
236                           newp->__data = data;
237                           newp->__next = NULL;
238
239                           lastp = &result->__data[cnt].__trans;
240                           while (*lastp != NULL)
241                             lastp = &(*lastp)->__next;
242
243                           *lastp = newp;
244                         }
245                       break;
246                     }
247
248               /* If this is the last step we must not allocate an
249                  output buffer.  */
250               if (cnt < nsteps - 1)
251                 {
252                   result->__data[cnt].__flags = conv_flags;
253
254                   /* Allocate the buffer.  */
255                   size = (GCONV_NCHAR_GOAL * steps[cnt].__max_needed_to);
256
257                   result->__data[cnt].__outbuf = (char *) malloc (size);
258                   if (result->__data[cnt].__outbuf == NULL)
259                     {
260                       res = __GCONV_NOMEM;
261                       goto bail;
262                     }
263
264                   result->__data[cnt].__outbufend =
265                     result->__data[cnt].__outbuf + size;
266                 }
267               else
268                 {
269                   /* Handle the last entry.  */
270                   result->__data[cnt].__flags = conv_flags | __GCONV_IS_LAST;
271
272                   break;
273                 }
274             }
275         }
276
277       if (res != __GCONV_OK)
278         {
279           /* Something went wrong.  Free all the resources.  */
280           int serrno;
281         bail:
282           serrno = errno;
283
284           if (result != NULL)
285             {
286               while (cnt-- > 0)
287                 {
288                   struct __gconv_trans_data *transp;
289
290                   transp = result->__data[cnt].__trans;
291                   while (transp != NULL)
292                     {
293                       struct __gconv_trans_data *curp = transp;
294                       transp = transp->__next;
295
296                       if (__builtin_expect (curp->__trans_end_fct != NULL, 0))
297                         curp->__trans_end_fct (curp->__data);
298
299                       free (curp);
300                     }
301
302                   free (result->__data[cnt].__outbuf);
303                 }
304
305               free (result);
306               result = NULL;
307             }
308
309           __gconv_close_transform (steps, nsteps);
310
311           __set_errno (serrno);
312         }
313     }
314
315   *handle = result;
316   return res;
317 }