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