(Old-style number conversion): Correct some typos.
[kopensolaris-gnu/glibc.git] / iconvdata / 8bit-gap.c
1 /* Generic conversion to and from 8bit charsets,
2    converting from UCS using gaps.
3    Copyright (C) 1997 Free Software Foundation, Inc.
4    This file is part of the GNU C Library.
5    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
6
7    The GNU C Library is free software; you can redistribute it and/or
8    modify it under the terms of the GNU Library General Public License as
9    published by the Free Software Foundation; either version 2 of the
10    License, or (at your option) any later version.
11
12    The GNU C Library is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15    Library General Public License for more details.
16
17    You should have received a copy of the GNU Library General Public
18    License along with the GNU C Library; see the file COPYING.LIB.  If not,
19    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20    Boston, MA 02111-1307, USA.  */
21
22 #include <gconv.h>
23 #include <inttypes.h>
24 #include <stdlib.h>
25 #include <string.h>
26
27
28 struct gap
29 {
30   uint16_t start;
31   uint16_t end;
32   int16_t idx;
33 };
34
35 /* Now we can include the tables.  */
36 #include TABLES
37
38 /* Direction of the transformation.  */
39 enum direction
40 {
41   illegal,
42   to_8bit,
43   from_8bit
44 };
45
46 struct s_8bit_data
47 {
48   enum direction dir;
49 };
50
51
52 int
53 gconv_init (struct gconv_step *step, struct gconv_step_data *data)
54 {
55   /* Determine which direction.  */
56   struct s_8bit_data *new_data;
57   enum direction dir;
58   int result;
59
60   if (__strcasestr (step->from_name, NAME) != NULL)
61     dir = from_8bit;
62   else if (__strcasestr (step->to_name, NAME) != NULL)
63     dir = to_8bit;
64   else
65     dir = illegal;
66
67   result = GCONV_NOCONV;
68   if (dir != illegal
69       && ((new_data
70            = (struct s_8bit_data *) malloc (sizeof (struct s_8bit_data)))
71           != NULL))
72     {
73       new_data->dir = dir;
74       data->data = new_data;
75       result = GCONV_OK;
76     }
77
78   return result;
79 }
80
81
82 void
83 gconv_end (struct gconv_step_data *data)
84 {
85   free (data->data);
86 }
87
88
89 int
90 gconv (struct gconv_step *step, struct gconv_step_data *data,
91        const char *inbuf, size_t *inbufsize, size_t *written, int do_flush)
92 {
93   struct gconv_step *next_step = step + 1;
94   struct gconv_step_data *next_data = data + 1;
95   gconv_fct fct = next_step->fct;
96   size_t do_write;
97   int result;
98
99   /* If the function is called with no input this means we have to reset
100      to the initial state.  The possibly partly converted input is
101      dropped.  */
102   if (do_flush)
103     {
104       do_write = 0;
105
106       /* Call the steps down the chain if there are any.  */
107       if (data->is_last)
108         result = GCONV_OK;
109       else
110         {
111           struct gconv_step *next_step = step + 1;
112           struct gconv_step_data *next_data = data + 1;
113
114           result = (*fct) (next_step, next_data, NULL, 0, written, 1);
115
116           /* Clear output buffer.  */
117           data->outbufavail = 0;
118         }
119     }
120   else
121     {
122       enum direction dir = ((struct s_8bit_data *) data->data)->dir;
123
124       do_write = 0;
125
126       do
127         {
128           result = GCONV_OK;
129
130           if (dir == from_8bit)
131             {
132               size_t inchars = *inbufsize;
133               size_t outwchars = data->outbufavail;
134               char *outbuf = data->outbuf;
135               size_t cnt = 0;
136
137               while (cnt < inchars
138                      && (outwchars + sizeof (wchar_t) <= data->outbufsize))
139                 {
140                   wchar_t ch = to_ucs4[(unsigned int) inbuf[cnt]];
141
142                   if (ch == L'\0' && inbuf[cnt] != '\0')
143                     {
144                       /* This is an illegal character.  */
145                       result = GCONV_ILLEGAL_INPUT;
146                       break;
147                     }
148
149                   *((wchar_t *) (outbuf + outwchars)) = ch;
150                   ++do_write;
151                   outwchars += sizeof (wchar_t);
152                   ++cnt;
153                 }
154               *inbufsize -= cnt;
155               data->outbufavail = outwchars;
156             }
157           else
158             {
159               size_t inwchars = *inbufsize;
160               size_t outchars = data->outbufavail;
161               char *outbuf = data->outbuf;
162               size_t cnt = 0;
163
164               while (inwchars >= cnt + sizeof (wchar_t)
165                      && outchars < data->outbufsize)
166                 {
167                   const struct gap *rp = from_idx;
168                   unsigned int ch = *((wchar_t *) (inbuf + cnt));
169                   char res;
170
171                   while (ch > rp->end)
172                     ++rp;
173                   if (ch < rp->start)
174                     /* No valid character.  */
175                     break;
176
177                   res = from_ucs4[ch + rp->idx];
178                   if (res == '\0' && ch != 0)
179                     /* No valid character.  */
180                     break;
181
182                   outbuf[outchars] = res;
183                   ++do_write;
184                   ++outchars;
185                   cnt += sizeof (wchar_t);
186                 }
187               *inbufsize -= cnt;
188               data->outbufavail = outchars;
189
190               if (outchars < data->outbufsize)
191                 {
192                   /* If there is still room in the output buffer something
193                      is wrong with the input.  */
194                   if (inwchars >= cnt + sizeof (wchar_t))
195                     {
196                       /* An error occurred.  */
197                       result = GCONV_ILLEGAL_INPUT;
198                       break;
199                     }
200                   if (inwchars != cnt)
201                     {
202                       /* There are some unprocessed bytes at the end of the
203                          input buffer.  */
204                       result = GCONV_INCOMPLETE_INPUT;
205                       break;
206                     }
207                 }
208             }
209
210           if (result != GCONV_OK)
211             break;
212
213           if (data->is_last)
214             {
215               /* This is the last step.  */
216               result = (*inbufsize > (dir == from_8bit
217                                       ? 0 : sizeof (wchar_t) - 1)
218                         ? GCONV_FULL_OUTPUT : GCONV_EMPTY_INPUT);
219               break;
220             }
221
222           /* Status so far.  */
223           result = GCONV_EMPTY_INPUT;
224
225           if (data->outbufavail > 0)
226             {
227               /* Call the functions below in the chain.  */
228               size_t newavail = data->outbufavail;
229
230               result = (*fct) (next_step, next_data, data->outbuf, &newavail,
231                                written, 0);
232
233               /* Correct the output buffer.  */
234               if (newavail != data->outbufavail && newavail > 0)
235                 {
236                   memmove (data->outbuf,
237                            &data->outbuf[data->outbufavail - newavail],
238                            newavail);
239                   data->outbufavail = newavail;
240                 }
241             }
242         }
243       while (*inbufsize > 0 && result == GCONV_EMPTY_INPUT);
244     }
245
246   if (written != NULL && data->is_last)
247     *written = do_write;
248
249   return result;
250 }