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