Adjust for renaming of __gconv_transliterate.
[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
41   /* Find out whether any error handling method is specified.  */
42   errhand = strchr (toset, '/');
43   if (errhand != NULL)
44     errhand = strchr (errhand + 1, '/');
45   if (__builtin_expect (errhand != NULL, 1))
46     {
47       if (errhand[1] == '\0')
48         errhand = NULL;
49       else
50         {
51           /* Make copy without the error handling description.  */
52           char *newtoset = (char *) alloca (errhand - toset + 1);
53
54           newtoset[errhand - toset] = '\0';
55           toset = memcpy (newtoset, toset, errhand - toset);
56
57           flags = __GCONV_IGNORE_ERRORS;
58
59           if (strcasecmp (errhand, "IGNORE") == 0)
60             {
61               /* Found it.  This means we should ignore conversion errors.  */
62               flags = __GCONV_IGNORE_ERRORS;
63               errhand = NULL;
64             }
65         }
66     }
67
68   res = __gconv_find_transform (toset, fromset, &steps, &nsteps, flags);
69   if (res == __GCONV_OK)
70     {
71       const char **csnames = NULL;
72       size_t ncsnames = 0;
73       __gconv_trans_fct trans_fct = NULL;
74       __gconv_trans_context_fct trans_context_fct = NULL;
75       __gconv_trans_init_fct trans_init_fct = NULL;
76       __gconv_trans_end_fct trans_end_fct = NULL;
77
78       if (errhand != NULL)
79         {
80           /* Find the appropriate transliteration handling.  */
81           if (strcasecmp (errhand, "TRANSLIT") == 0)
82             {
83               /* It's the builtin transliteration handling.  We only
84                  suport for it working on the internal encoding.  */
85               static const char *internal_trans_names[1] = { "INTERNAL" };
86
87               csnames = internal_trans_names;
88               ncsnames = 1;
89               trans_fct = __gconv_transliterate;
90               /* No context, init, or end function.  */
91             }
92           else if (strcasecmp (errhand, "WORK AROUND A GCC BUG") == 0)
93             {
94               trans_init_fct = (__gconv_trans_init_fct) 1;
95             }
96         }
97
98       /* Allocate room for handle.  */
99       result = (__gconv_t) malloc (sizeof (struct __gconv_info)
100                                    + (nsteps
101                                       * sizeof (struct __gconv_step_data)));
102       if (result == NULL)
103         res = __GCONV_NOMEM;
104       else
105         {
106           size_t n;
107
108           /* Remember the list of steps.  */
109           result->__steps = steps;
110           result->__nsteps = nsteps;
111
112           /* Clear the array for the step data.  */
113           memset (result->__data, '\0',
114                   nsteps * sizeof (struct __gconv_step_data));
115
116           /* Call all initialization functions for the transformation
117              step implementations.  */
118           for (cnt = 0; cnt < nsteps - 1; ++cnt)
119             {
120               size_t size;
121
122               /* Would have to be done if we would not clear the whole
123                  array above.  */
124               /* If this is the last step we must not allocate an
125                  output buffer.  */
126               result->__data[cnt].__flags = conv_flags;
127
128 #if 0
129               /* Reset the counter.  */
130               result->__data[cnt].__invocation_counter = 0;
131
132               /* It's a regular use.  */
133               result->__data[cnt].__internal_use = 0;
134 #endif
135
136               /* We use the `mbstate_t' member in DATA.  */
137               result->__data[cnt].__statep = &result->__data[cnt].__state;
138
139               /* Allocate the buffer.  */
140               size = (GCONV_NCHAR_GOAL * steps[cnt].__max_needed_to);
141
142               result->__data[cnt].__outbuf = (char *) malloc (size);
143               if (result->__data[cnt].__outbuf == NULL)
144                 {
145                   res = __GCONV_NOMEM;
146                   break;
147                 }
148               result->__data[cnt].__outbufend =
149                 result->__data[cnt].__outbuf + size;
150
151               /* Now see whether we can use the transliteration module
152                  for this step.  */
153               for (n = 0; n < ncsnames; ++n)
154                 if (strcasecmp (steps[cnt].__from_name, csnames[n]) == 0)
155                   {
156                     /* Match!  Now try the initializer.  */
157                     if (trans_init_fct == NULL
158                         || (trans_init_fct (&result->__data[cnt].__trans.__data,
159                                             steps[cnt].__to_name)
160                             == __GCONV_OK))
161                       {
162                         result->__data[cnt].__trans.__trans_fct = trans_fct;
163                         result->__data[cnt].__trans.__trans_context_fct =
164                           trans_context_fct;
165                         result->__data[cnt].__trans.__trans_end_fct =
166                           trans_end_fct;
167                       }
168                     break;
169                   }
170             }
171
172           /* Now handle the last entry.  */
173           result->__data[cnt].__flags = conv_flags | __GCONV_IS_LAST;
174           /* Would have to be done if we would not clear the whole
175              array above.  */
176 #if 0
177           result->__data[cnt].__invocation_counter = 0;
178           result->__data[cnt].__internal_use = 0;
179 #endif
180           result->__data[cnt].__statep = &result->__data[cnt].__state;
181
182           /* Now see whether we can use the transliteration module
183              for this step.  */
184           for (n = 0; n < ncsnames; ++n)
185             if (strcasecmp (steps[cnt].__from_name, csnames[n]) == 0)
186               {
187                 /* Match!  Now try the initializer.  */
188                 if (trans_init_fct == NULL
189                     || trans_init_fct (&result->__data[cnt].__trans.__data,
190                                        steps[cnt].__to_name)
191                     == __GCONV_OK)
192                   {
193                     result->__data[cnt].__trans.__trans_fct = trans_fct;
194                     result->__data[cnt].__trans.__trans_context_fct =
195                       trans_context_fct;
196                     result->__data[cnt].__trans.__trans_end_fct =
197                       trans_end_fct;
198                   }
199                 break;
200               }
201         }
202
203       if (res != __GCONV_OK)
204         {
205           /* Something went wrong.  Free all the resources.  */
206           int serrno = errno;
207
208           if (result != NULL)
209             {
210               while (cnt-- > 0)
211                 free (result->__data[cnt].__outbuf);
212
213               free (result);
214               result = NULL;
215             }
216
217           __gconv_close_transform (steps, nsteps);
218
219           __set_errno (serrno);
220         }
221     }
222
223   *handle = result;
224   return res;
225 }