Define get16, get32, put16, and put32 macros to allow as well reading
[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 <endian.h>
49 #include <gconv.h>
50 #include <stdint.h>
51 #include <string.h>
52 #include <wchar.h>
53 #include <sys/param.h>          /* For MIN.  */
54 #define __need_size_t
55 #include <stddef.h>
56
57
58 /* We have to provide support for machines which are not able to handled
59    unaligned memory accesses.  Some of the character encodings have
60    representations with a fixed width of 2 or 4 bytes.  But if we cannot
61    access unaligned memory we still have to read byte-wise.  */
62 #undef FCTNAME2
63 #if defined _STRING_ARCH_unaligned || !defined DEFINE_UNALIGNED
64 /* We can handle unaligned memory access.  */
65 # define get16(addr) *((uint16_t *) (addr))
66 # define get32(addr) *((uint32_t *) (addr))
67
68 /* We need no special support for writing values either.  */
69 # define put16(addr, val) *((uint16_t *) (addr)) = (val)
70 # define put32(addr, val) *((uint32_t *) (addr)) = (val)
71
72 # define FCTNAME2(name) name
73 #else
74 /* Distinguish between big endian and little endian.  */
75 # if __BYTE_ORDER == __LITTLE_ENDIAN
76 #  define get16(addr) \
77      (((__const unsigned char *) (addr))[1] << 8                              \
78       | ((__const unsigned char *) (addr))[0])
79 #  define get32(addr) \
80      (((((__const unsigned char *) (addr))[3] << 8                            \
81         | ((__const unsigned char *) (addr))[2]) << 8                         \
82        | ((__const unsigned char *) (addr))[1]) << 8                          \
83       | ((__const unsigned char *) (addr))[0])
84
85 # define put16(addr, val) \
86      ({ uint16_t __val = (val);                                               \
87         ((__const unsigned char *) (addr))[0] = __val;                        \
88         ((__const unsigned char *) (addr))[1] = __val >> 8;                   \
89         (void) 0; })
90 # define put32(addr, val) \
91      ({ uint16_t __val = (val);                                               \
92         ((__const unsigned char *) (addr))[0] = __val;                        \
93         __val >>= 8;                                                          \
94         ((__const unsigned char *) (addr))[1] = __val;                        \
95         __val >>= 8;                                                          \
96         ((__const unsigned char *) (addr))[2] = __val;                        \
97         __val >>= 8;                                                          \
98         ((__const unsigned char *) (addr))[3] = __val;                        \
99         (void) 0; })
100 # else
101 #  define get16(addr) \
102      (((__const unsigned char *) (addr))[0] << 8                              \
103       | ((__const unsigned char *) (addr))[1])
104 #  define get32(addr) \
105      (((((__const unsigned char *) (addr))[0] << 8                            \
106         | ((__const unsigned char *) (addr))[1]) << 8                         \
107        | ((__const unsigned char *) (addr))[2]) << 8                          \
108       | ((__const unsigned char *) (addr))[3])
109
110 # define put16(addr, val) \
111      ({ uint16_t __val = (val);                                               \
112         ((__const unsigned char *) (addr))[1] = __val;                        \
113         ((__const unsigned char *) (addr))[2] = __val >> 8;                   \
114         (void) 0; })
115 # define put32(addr, val) \
116      ({ uint16_t __val = (val);                                               \
117         ((__const unsigned char *) (addr))[3] = __val;                        \
118         __val >>= 8;                                                          \
119         ((__const unsigned char *) (addr))[2] = __val;                        \
120         __val >>= 8;                                                          \
121         ((__const unsigned char *) (addr))[1] = __val;                        \
122         __val >>= 8;                                                          \
123         ((__const unsigned char *) (addr))[0] = __val;                        \
124         (void) 0; })
125 # endif
126
127 # define FCTNAME2(name) name##_unaligned
128 #endif
129 #define FCTNAME(name) FCTNAME2(name)
130
131
132 /* We need at least one byte for the next round.  */
133 #ifndef MIN_NEEDED_INPUT
134 # error "MIN_NEEDED_INPUT definition missing"
135 #endif
136
137 /* Let's see how many bytes we produce.  */
138 #ifndef MAX_NEEDED_INPUT
139 # define MAX_NEEDED_INPUT       MIN_NEEDED_INPUT
140 #endif
141
142 /* We produce at least one byte in the next round.  */
143 #ifndef MIN_NEEDED_OUTPUT
144 # error "MIN_NEEDED_OUTPUT definition missing"
145 #endif
146
147 /* Let's see how many bytes we produce.  */
148 #ifndef MAX_NEEDED_OUTPUT
149 # define MAX_NEEDED_OUTPUT      MIN_NEEDED_OUTPUT
150 #endif
151
152 /* Default name for the function.  */
153 #ifndef LOOPFCT
154 # define LOOPFCT                loop
155 #endif
156
157 /* Make sure we have a loop body.  */
158 #ifndef BODY
159 # error "Definition of BODY missing for function" LOOPFCT
160 #endif
161
162
163 /* If no arguments have to passed to the loop function define the macro
164    as empty.  */
165 #ifndef EXTRA_LOOP_DECLS
166 # define EXTRA_LOOP_DECLS
167 #endif
168
169
170 /* The function returns the status, as defined in gconv.h.  */
171 static inline int
172 FCTNAME (LOOPFCT) (const unsigned char **inptrp, const unsigned char *inend,
173                    unsigned char **outptrp, unsigned char *outend,
174                    mbstate_t *state, void *data, size_t *converted
175                    EXTRA_LOOP_DECLS)
176 {
177   int result = __GCONV_OK;
178   const unsigned char *inptr = *inptrp;
179   unsigned char *outptr = *outptrp;
180
181   /* We run one loop where we avoid checks for underflow/overflow of the
182      buffers to speed up the conversion a bit.  */
183   size_t min_in_rounds = (inend - inptr) / MAX_NEEDED_INPUT;
184   size_t min_out_rounds = (outend - outptr) / MAX_NEEDED_OUTPUT;
185   size_t min_rounds = MIN (min_in_rounds, min_out_rounds);
186
187 #ifdef INIT_PARAMS
188   INIT_PARAMS;
189 #endif
190
191 #undef NEED_LENGTH_TEST
192 #define NEED_LENGTH_TEST        0
193   while (min_rounds-- > 0)
194     {
195       /* Here comes the body the user provides.  It can stop with RESULT
196          set to GCONV_INCOMPLETE_INPUT (if the size of the input characters
197          vary in size), GCONV_ILLEGAL_INPUT, or GCONV_FULL_OUTPUT (if the
198          output characters vary in size.  */
199       BODY
200     }
201
202   if (result == __GCONV_OK)
203     {
204 #if MIN_NEEDED_INPUT == MAX_NEEDED_INPUT \
205     && MIN_NEEDED_OUTPUT == MAX_NEEDED_OUTPUT
206       /* We don't need to start another loop since we were able to determine
207          the maximal number of characters to copy in advance.  What remains
208          to be determined is the status.  */
209       if (inptr == inend)
210         /* No more input.  */
211         result = __GCONV_EMPTY_INPUT;
212       else if ((MIN_NEEDED_OUTPUT != 1 && outptr + MIN_NEEDED_OUTPUT > outend)
213                || (MIN_NEEDED_OUTPUT == 1 && outptr >= outend))
214         /* Overflow in the output buffer.  */
215         result = __GCONV_FULL_OUTPUT;
216       else
217         /* We have something left in the input buffer.  */
218         result = __GCONV_INCOMPLETE_INPUT;
219 #else
220       result = __GCONV_EMPTY_INPUT;
221
222 # undef NEED_LENGTH_TEST
223 # define NEED_LENGTH_TEST       1
224       while (inptr != inend)
225         {
226           /* `if' cases for MIN_NEEDED_OUTPUT ==/!= 1 is made to help the
227              compiler generating better code.  It will optimized away
228              since MIN_NEEDED_OUTPUT is always a constant.  */
229           if ((MIN_NEEDED_OUTPUT != 1 && outptr + MIN_NEEDED_OUTPUT > outend)
230               || (MIN_NEEDED_OUTPUT == 1 && outptr >= outend))
231             {
232               /* Overflow in the output buffer.  */
233               result = __GCONV_FULL_OUTPUT;
234               break;
235             }
236           if (MIN_NEEDED_INPUT > 1 && inptr + MIN_NEEDED_INPUT > inend)
237             {
238               /* We don't have enough input for another complete input
239                  character.  */
240               result = __GCONV_INCOMPLETE_INPUT;
241               break;
242             }
243
244           /* Here comes the body the user provides.  It can stop with
245              RESULT set to GCONV_INCOMPLETE_INPUT (if the size of the
246              input characters vary in size), GCONV_ILLEGAL_INPUT, or
247              GCONV_FULL_OUTPUT (if the output characters vary in size).  */
248           BODY
249         }
250 #endif  /* Input and output charset are not both fixed width.  */
251     }
252
253   /* Update the pointers pointed to by the parameters.  */
254   *inptrp = inptr;
255   *outptrp = outptr;
256 #ifdef UPDATE_PARAMS
257   UPDATE_PARAMS;
258 #endif
259
260   return result;
261 }
262
263
264 /* Include the file a second time to define the function to define the
265    function to handle unaligned access.  */
266 #if !defined _STRING_ARCH_unaligned && !defined DEFINE_UNALIGNED
267 # define DEFINE_UNALIGNED
268 # include "loop.c"
269 # undef DEFINE_UNALIGNED
270 #endif
271
272
273 /* We remove the macro definitions so that we can include this file again
274    for the definition of another function.  */
275 #undef MIN_NEEDED_INPUT
276 #undef MAX_NEEDED_INPUT
277 #undef MIN_NEEDED_OUTPUT
278 #undef MAX_NEEDED_OUTPUT
279 #undef LOOPFCT
280 #undef BODY
281 #undef LOOPFCT
282 #undef EXTRA_LOOP_DECLS
283 #undef INIT_PARAMS
284 #undef UPDATE_PARAMS
285
286 #undef get16
287 #undef get32
288 #undef put16
289 #undef put32