(__GCONV_IS_LAST, __GCONV_IGNORE_ERRORS): Define.
[kopensolaris-gnu/glibc.git] / iconv / loop.c
1 /* Conversion loop frame work.
2    Copyright (C) 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>, 1998.
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 /* This file provides a frame for the reader loop in all conversion modules.
22    The actual code must (of course) be provided in the actual module source
23    code but certain actions can be written down generically, with some
24    customization options which are these:
25
26      MIN_NEEDED_INPUT   minimal number of input bytes needed for the next
27                         conversion.
28      MIN_NEEDED_OUTPUT  minimal number of bytes produced by the next round
29                         of conversion.
30
31      MAX_NEEDED_INPUT   you guess it, this is the maximal number of input
32                         bytes needed.  It defaults to MIN_NEEDED_INPUT
33      MAX_NEEDED_OUTPUT  likewise for output bytes.
34
35      LOOPFCT            name of the function created.  If not specified
36                         the name is `loop' but this prevents the use
37                         of multiple functions in the same file.
38
39      BODY               this is supposed to expand to the body of the loop.
40                         The user must provide this.
41
42      EXTRA_LOOP_DECLS   extra arguments passed from converion loop call.
43
44      INIT_PARAMS        code to define and initialize variables from params.
45      UPDATE_PARAMS      code to store result in params.
46 */
47
48 #include <assert.h>
49 #include <endian.h>
50 #include <gconv.h>
51 #include <stdint.h>
52 #include <string.h>
53 #include <wchar.h>
54 #include <sys/param.h>          /* For MIN.  */
55 #define __need_size_t
56 #include <stddef.h>
57
58
59 /* We have to provide support for machines which are not able to handled
60    unaligned memory accesses.  Some of the character encodings have
61    representations with a fixed width of 2 or 4 bytes.  But if we cannot
62    access unaligned memory we still have to read byte-wise.  */
63 #undef FCTNAME2
64 #if defined _STRING_ARCH_unaligned || !defined DEFINE_UNALIGNED
65 /* We can handle unaligned memory access.  */
66 # define get16(addr) *((uint16_t *) (addr))
67 # define get32(addr) *((uint32_t *) (addr))
68
69 /* We need no special support for writing values either.  */
70 # define put16(addr, val) *((uint16_t *) (addr)) = (val)
71 # define put32(addr, val) *((uint32_t *) (addr)) = (val)
72
73 # define FCTNAME2(name) name
74 #else
75 /* Distinguish between big endian and little endian.  */
76 # if __BYTE_ORDER == __LITTLE_ENDIAN
77 #  define get16(addr) \
78      (((__const unsigned char *) (addr))[1] << 8                              \
79       | ((__const unsigned char *) (addr))[0])
80 #  define get32(addr) \
81      (((((__const unsigned char *) (addr))[3] << 8                            \
82         | ((__const unsigned char *) (addr))[2]) << 8                         \
83        | ((__const unsigned char *) (addr))[1]) << 8                          \
84       | ((__const unsigned char *) (addr))[0])
85
86 #  define put16(addr, val) \
87      ({ uint16_t __val = (val);                                               \
88         ((unsigned char *) (addr))[0] = __val;                                \
89         ((unsigned char *) (addr))[1] = __val >> 8;                           \
90         (void) 0; })
91 #  define put32(addr, val) \
92      ({ uint32_t __val = (val);                                               \
93         ((unsigned char *) (addr))[0] = __val;                                \
94         __val >>= 8;                                                          \
95         ((unsigned char *) (addr))[1] = __val;                                \
96         __val >>= 8;                                                          \
97         ((unsigned char *) (addr))[2] = __val;                                \
98         __val >>= 8;                                                          \
99         ((unsigned char *) (addr))[3] = __val;                                \
100         (void) 0; })
101 # else
102 #  define get16(addr) \
103      (((__const unsigned char *) (addr))[0] << 8                              \
104       | ((__const unsigned char *) (addr))[1])
105 #  define get32(addr) \
106      (((((__const unsigned char *) (addr))[0] << 8                            \
107         | ((__const unsigned char *) (addr))[1]) << 8                         \
108        | ((__const unsigned char *) (addr))[2]) << 8                          \
109       | ((__const unsigned char *) (addr))[3])
110
111 #  define put16(addr, val) \
112      ({ uint16_t __val = (val);                                               \
113         ((unsigned char *) (addr))[1] = __val;                                \
114         ((unsigned char *) (addr))[2] = __val >> 8;                           \
115         (void) 0; })
116 #  define put32(addr, val) \
117      ({ uint32_t __val = (val);                                               \
118         ((unsigned char *) (addr))[3] = __val;                                \
119         __val >>= 8;                                                          \
120         ((unsigned char *) (addr))[2] = __val;                                \
121         __val >>= 8;                                                          \
122         ((unsigned char *) (addr))[1] = __val;                                \
123         __val >>= 8;                                                          \
124         ((unsigned char *) (addr))[0] = __val;                                \
125         (void) 0; })
126 # endif
127
128 # define FCTNAME2(name) name##_unaligned
129 #endif
130 #define FCTNAME(name) FCTNAME2(name)
131
132
133 /* We need at least one byte for the next round.  */
134 #ifndef MIN_NEEDED_INPUT
135 # error "MIN_NEEDED_INPUT definition missing"
136 #endif
137
138 /* Let's see how many bytes we produce.  */
139 #ifndef MAX_NEEDED_INPUT
140 # define MAX_NEEDED_INPUT       MIN_NEEDED_INPUT
141 #endif
142
143 /* We produce at least one byte in the next round.  */
144 #ifndef MIN_NEEDED_OUTPUT
145 # error "MIN_NEEDED_OUTPUT definition missing"
146 #endif
147
148 /* Let's see how many bytes we produce.  */
149 #ifndef MAX_NEEDED_OUTPUT
150 # define MAX_NEEDED_OUTPUT      MIN_NEEDED_OUTPUT
151 #endif
152
153 /* Default name for the function.  */
154 #ifndef LOOPFCT
155 # define LOOPFCT                loop
156 #endif
157
158 /* Make sure we have a loop body.  */
159 #ifndef BODY
160 # error "Definition of BODY missing for function" LOOPFCT
161 #endif
162
163
164 /* If no arguments have to passed to the loop function define the macro
165    as empty.  */
166 #ifndef EXTRA_LOOP_DECLS
167 # define EXTRA_LOOP_DECLS
168 #endif
169
170
171 /* The function returns the status, as defined in gconv.h.  */
172 static inline int
173 FCTNAME (LOOPFCT) (const unsigned char **inptrp, const unsigned char *inend,
174                    unsigned char **outptrp, unsigned char *outend,
175                    mbstate_t *state, void *data, size_t *converted
176                    EXTRA_LOOP_DECLS)
177 {
178   int result = __GCONV_OK;
179   const unsigned char *inptr = *inptrp;
180   unsigned char *outptr = *outptrp;
181
182   /* We run one loop where we avoid checks for underflow/overflow of the
183      buffers to speed up the conversion a bit.  */
184   size_t min_in_rounds = (inend - inptr) / MAX_NEEDED_INPUT;
185   size_t min_out_rounds = (outend - outptr) / MAX_NEEDED_OUTPUT;
186   size_t min_rounds = MIN (min_in_rounds, min_out_rounds);
187
188 #ifdef INIT_PARAMS
189   INIT_PARAMS;
190 #endif
191
192 #undef NEED_LENGTH_TEST
193 #define NEED_LENGTH_TEST        0
194   while (min_rounds-- > 0)
195     {
196       /* Here comes the body the user provides.  It can stop with RESULT
197          set to GCONV_INCOMPLETE_INPUT (if the size of the input characters
198          vary in size), GCONV_ILLEGAL_INPUT, or GCONV_FULL_OUTPUT (if the
199          output characters vary in size.  */
200       BODY
201     }
202
203   if (result == __GCONV_OK)
204     {
205 #if MIN_NEEDED_INPUT == MAX_NEEDED_INPUT \
206     && MIN_NEEDED_OUTPUT == MAX_NEEDED_OUTPUT
207       /* We don't need to start another loop since we were able to determine
208          the maximal number of characters to copy in advance.  What remains
209          to be determined is the status.  */
210       if (inptr == inend)
211         /* No more input.  */
212         result = __GCONV_EMPTY_INPUT;
213       else if ((MIN_NEEDED_OUTPUT != 1 && outptr + MIN_NEEDED_OUTPUT > outend)
214                || (MIN_NEEDED_OUTPUT == 1 && outptr >= outend))
215         /* Overflow in the output buffer.  */
216         result = __GCONV_FULL_OUTPUT;
217       else
218         /* We have something left in the input buffer.  */
219         result = __GCONV_INCOMPLETE_INPUT;
220 #else
221       result = __GCONV_EMPTY_INPUT;
222
223 # undef NEED_LENGTH_TEST
224 # define NEED_LENGTH_TEST       1
225       while (inptr != inend)
226         {
227           /* `if' cases for MIN_NEEDED_OUTPUT ==/!= 1 is made to help the
228              compiler generating better code.  It will optimized away
229              since MIN_NEEDED_OUTPUT is always a constant.  */
230           if ((MIN_NEEDED_OUTPUT != 1 && outptr + MIN_NEEDED_OUTPUT > outend)
231               || (MIN_NEEDED_OUTPUT == 1 && outptr >= outend))
232             {
233               /* Overflow in the output buffer.  */
234               result = __GCONV_FULL_OUTPUT;
235               break;
236             }
237           if (MIN_NEEDED_INPUT > 1 && inptr + MIN_NEEDED_INPUT > inend)
238             {
239               /* We don't have enough input for another complete input
240                  character.  */
241               result = __GCONV_INCOMPLETE_INPUT;
242               break;
243             }
244
245           /* Here comes the body the user provides.  It can stop with
246              RESULT set to GCONV_INCOMPLETE_INPUT (if the size of the
247              input characters vary in size), GCONV_ILLEGAL_INPUT, or
248              GCONV_FULL_OUTPUT (if the output characters vary in size).  */
249           BODY
250         }
251 #endif  /* Input and output charset are not both fixed width.  */
252     }
253
254   /* Update the pointers pointed to by the parameters.  */
255   *inptrp = inptr;
256   *outptrp = outptr;
257 #ifdef UPDATE_PARAMS
258   UPDATE_PARAMS;
259 #endif
260
261   return result;
262 }
263
264
265 /* Include the file a second time to define the function to define the
266    function to handle unaligned access.  */
267 #if !defined DEFINE_UNALIGNED && !defined _STRING_ARCH_unaligned \
268     && MIN_NEEDED_FROM != 1 && MAX_NEEDED_FROM % MIN_NEEDED_FROM == 0 \
269     && MIN_NEEDED_TO != 1 && MAX_NEEDED_TO % MIN_NEEDED_TO == 0
270 # undef get16
271 # undef get32
272 # undef put16
273 # undef put32
274 # undef unaligned
275
276 # define DEFINE_UNALIGNED
277 # include "loop.c"
278 # undef DEFINE_UNALIGNED
279 #endif
280
281
282 #if MAX_NEEDED_INPUT > 1
283 # define SINGLE(fct) SINGLE2 (fct)
284 # define SINGLE2(fct) fct##_single
285 static inline int
286 SINGLE(LOOPFCT) (const unsigned char **inptrp, const unsigned char *inend,
287                  unsigned char **outptrp, unsigned char *outend,
288                  mbstate_t *state, void *data, size_t *converted
289                  EXTRA_LOOP_DECLS)
290 {
291   int result = __GCONV_OK;
292   unsigned char bytebuf[MAX_NEEDED_INPUT];
293   const unsigned char *inptr = *inptrp;
294   unsigned char *outptr = *outptrp;
295   size_t inlen;
296
297 #ifdef INIT_PARAMS
298   INIT_PARAMS;
299 #endif
300
301 #ifdef UNPACK_BYTES
302   UNPACK_BYTES
303 #else
304   /* Add the bytes from the state to the input buffer.  */
305   for (inlen = 0; inlen < (state->__count & 7); ++ inlen)
306     bytebuf[inlen] = state->__value.__wchb[inlen];
307 #endif
308
309   /* Are there enough bytes in the input buffer?  */
310   if (__builtin_expect (inptr + (MIN_NEEDED_INPUT - inlen) > inend, 0))
311     {
312       *inptrp = inend;
313 #ifdef STORE_REST
314       inptr = bytebuf;
315       inptrp = &inptr;
316       inend = &bytebuf[inlen];
317
318       STORE_REST
319 #else
320       /* We don't have enough input for another complete input
321          character.  */
322       while (inptr < inend)
323         state->__value.__wchb[inlen++] = *inptr++;
324 #endif
325
326       return __GCONV_INCOMPLETE_INPUT;
327     }
328
329   /* Enough space in output buffer.  */
330   if ((MIN_NEEDED_OUTPUT != 1 && outptr + MIN_NEEDED_OUTPUT > outend)
331       || (MIN_NEEDED_OUTPUT == 1 && outptr >= outend))
332     /* Overflow in the output buffer.  */
333     return __GCONV_FULL_OUTPUT;
334
335   /*  Now add characters from the normal input buffer.  */
336   do
337     bytebuf[inlen++] = *inptr++;
338   while (inlen < MAX_NEEDED_INPUT && inptr < inend);
339
340   inptr = bytebuf;
341   inend = &bytebuf[inlen];
342 #undef NEED_LENGTH_TEST
343 #define NEED_LENGTH_TEST        1
344   do
345     {
346       BODY
347     }
348   while (0);
349
350   /* Now we either have produced an output character and consumed all the
351      bytes from the state and at least one more, or the character is still
352      incomplete, or we have some other error (like illegal input character,
353      no space in output buffer).  */
354   if (inptr != bytebuf)
355     {
356       /* We found a new character.  */
357       assert (inptr - bytebuf > (state->__count & 7));
358
359       *inptrp += inptr - bytebuf - (state->__count & 7);
360       *outptrp = outptr;
361
362       result = __GCONV_OK;
363
364       /* Clear the state buffer.  */
365       state->__count &= ~7;
366     }
367   else if (result == __GCONV_INCOMPLETE_INPUT)
368     {
369       /* This can only happen if we have less than MAX_NEEDED_INPUT bytes
370          available.  */
371       assert (inend != &bytebuf[MAX_NEEDED_INPUT]);
372
373       *inptrp += inend - bytebuf - (state->__count & 7);
374 #ifdef STORE_REST
375       inptrp = &inptr;
376
377       STORE_REST
378 #else
379       /* We don't have enough input for another complete input
380          character.  */
381       while (inptr < inend)
382         state->__value.__wchb[inlen++] = *inptr++;
383 #endif
384     }
385
386   return result;
387 }
388 # undef SINGLE
389 # undef SINGLE2
390 #endif
391
392
393 /* We remove the macro definitions so that we can include this file again
394    for the definition of another function.  */
395 #undef MIN_NEEDED_INPUT
396 #undef MAX_NEEDED_INPUT
397 #undef MIN_NEEDED_OUTPUT
398 #undef MAX_NEEDED_OUTPUT
399 #undef LOOPFCT
400 #undef BODY
401 #undef LOOPFCT
402 #undef EXTRA_LOOP_DECLS
403 #undef INIT_PARAMS
404 #undef UPDATE_PARAMS
405 #undef get16
406 #undef get32
407 #undef put16
408 #undef put32
409 #undef unaligned
410 #undef UNPACK_BYTES