Allow EXTRA_LOOP_DECLS be defined and use it in function declaration.
[kopensolaris-gnu/glibc.git] / iconv / loop.c
1 /* Conversion loop frame work.
2    Copyright (C) 1998 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      COUNT_CONVERTED    optional macro which is used to count the actual
40                         number of characters converted.  For some conversion
41                         it is easy to compute the value afterwards, but for
42                         others explicit counting is cheaper.
43
44      BODY               this is supposed to expand to the body of the loop.
45                         The user must provide this.
46
47      EXTRA_LOOP_DECLS   Extra arguments passed from converion loop call.
48 */
49
50 #include <gconv.h>
51 #include <sys/param.h>          /* For MIN.  */
52 #define __need_size_t
53 #include <stddef.h>
54
55
56 /* We need at least one byte for the next round.  */
57 #ifndef MIN_NEEDED_INPUT
58 # error "MIN_NEEDED_INPUT definition missing"
59 #endif
60
61 /* Let's see how many bytes we produce.  */
62 #ifndef MAX_NEEDED_INPUT
63 # define MAX_NEEDED_INPUT       MIN_NEEDED_INPUT
64 #endif
65
66 /* We produce at least one byte in the next round.  */
67 #ifndef MIN_NEEDED_OUTPUT
68 # error "MIN_NEEDED_OUTPUT definition missing"
69 #endif
70
71 /* Let's see how many bytes we produce.  */
72 #ifndef MAX_NEEDED_OUTPUT
73 # define MAX_NEEDED_OUTPUT      MIN_NEEDED_OUTPUT
74 #endif
75
76 /* Default name for the function.  */
77 #ifndef LOOPFCT
78 # define LOOPFCT                loop
79 #endif
80
81 /* Make sure we have a loop body.  */
82 #ifndef BODY
83 # error "Definition of BODY missing for function" LOOPFCT
84 #endif
85
86 /* We can calculate the number of converted characters easily if one
87    of the character sets has a fixed width.  */
88 #ifndef COUNT_CONVERTED
89 # if MIN_NEEDED_INPUT == MAX_NEEDED_INPUT
90 #  if MIN_NEEDED_OUTPUT == MAX_NEEDED_OUTPUT
91 /* Decide whether one of the charsets has size 1.  */
92 #   if MIN_NEEDED_INPUT == 1
93 #    define COUNT_CONVERTED     (inptr - *inptrp)
94 #   elif MIN_NEEDED_OUTPUT == 1
95 #    define COUNT_CONVERTED     (outptr - *outptrp)
96 #   else
97 /* Else we should see whether one of the two numbers is a power of 2.  */
98 #    define COUNT_CONVERTED \
99   ((MIN_NEEDED_INPUT & (-MIN_NEEDED_INPUT)) == MIN_NEEDED_INPUT               \
100    ? (inptr - *inptrp) : (outptr - *outptrp))
101 #   endif
102 #  else
103 #   define COUNT_CONVERTED      (inptr - *inptrp)
104 #  endif
105 # elif MIN_NEEDED_OUTPUT == MAX_NEEDED_OUTPUT
106 #  define COUNT_CONVERTED       (outptr - *outptrp)
107 # endif
108 #endif
109
110
111 /* If no arguments have to passed to the loop function define the macro
112    as empty.  */
113 #ifndef EXTRA_LOOP_DECLS
114 # define EXTRA_LOOP_DECLS
115 #endif
116
117
118 /* The function returns the status, as defined in gconv.h.  */
119 static inline int
120 LOOPFCT (const unsigned char **inptrp, const unsigned char *inend,
121          unsigned char **outptrp, unsigned char *outend, mbstate_t *state,
122          void *data, size_t *converted EXTRA_LOOP_DECLS)
123 {
124   int result = GCONV_OK;
125   const unsigned char *inptr = *inptrp;
126   unsigned char *outptr = *outptrp;
127 #ifndef COUNT_CONVERTED
128   size_t done = 0;
129 #endif
130
131   /* We run one loop where we avoid checks for underflow/overflow of the
132      buffers to speed up the conversion a bit.  */
133   size_t min_in_rounds = (inend - inptr) / MAX_NEEDED_INPUT;
134   size_t min_out_rounds = (outend - outptr) / MAX_NEEDED_OUTPUT;
135   size_t min_rounds = MIN (min_in_rounds, min_out_rounds);
136
137 #undef NEED_LENGTH_TEST
138 #define NEED_LENGTH_TEST        0
139   while (min_rounds-- > 0)
140     {
141       /* Here comes the body the user provides.  It can stop with RESULT
142          set to GCONV_INCOMPLETE_INPUT (if the size of the input characters
143          vary in size), GCONV_ILLEGAL_INPUT, or GCONV_FULL_OUTPUT (if the
144          output characters vary in size.  */
145       BODY
146
147       /* If necessary count the successful conversion.  */
148 #ifndef COUNT_CONVERTED
149       ++done;
150 #endif
151     }
152
153   if (result == GCONV_OK)
154     {
155 #if MIN_NEEDED_INPUT == MAX_NEEDED_INPUT \
156     && MIN_NEEDED_OUTPUT == MAX_NEEDED_OUTPUT
157       /* We don't need to start another loop since we were able to determine
158          the maximal number of characters to copy in advance.  What remains
159          to be determined is the status.  */
160       if (inptr == inend)
161         /* No more input.  */
162         result = GCONV_EMPTY_INPUT;
163       else if ((MIN_NEEDED_OUTPUT != 1 && outptr + MIN_NEEDED_OUTPUT > outend)
164                || (MIN_NEEDED_OUTPUT == 1 && outptr >= outend))
165         /* Overflow in the output buffer.  */
166         result = GCONV_FULL_OUTPUT;
167       else
168         /* We have something left in the input buffer.  */
169         result = GCONV_INCOMPLETE_INPUT;
170 #else
171       result = GCONV_EMPTY_INPUT;
172
173 # undef NEED_LENGTH_TEST
174 # define NEED_LENGTH_TEST       1
175       while (inptr != inend)
176         {
177           /* `if' cases for MIN_NEEDED_OUTPUT ==/!= 1 is made to help the
178              compiler generating better code.  It will optimized away
179              since MIN_NEEDED_OUTPUT is always a constant.  */
180           if ((MIN_NEEDED_OUTPUT != 1 && outptr + MIN_NEEDED_OUTPUT > outend)
181               || (MIN_NEEDED_OUTPUT == 1 && outptr >= outend))
182             {
183               /* Overflow in the output buffer.  */
184               result = GCONV_FULL_OUTPUT;
185               break;
186             }
187           if (MIN_NEEDED_INPUT > 1 && inptr + MIN_NEEDED_INPUT > inend)
188             {
189               /* We don't have enough input for another complete input
190                  character.  */
191               result = GCONV_INCOMPLETE_INPUT;
192               break;
193             }
194
195           /* Here comes the body the user provides.  It can stop with
196              RESULT set to GCONV_INCOMPLETE_INPUT (if the size of the
197              input characters vary in size), GCONV_ILLEGAL_INPUT, or
198              GCONV_FULL_OUTPUT (if the output characters vary in size.  */
199           BODY
200
201           /* If necessary count the successful conversion.  */
202 # ifndef COUNT_CONVERTED
203           ++done;
204 # endif
205         }
206 #endif  /* Input and output charset are not both fixed width.  */
207     }
208
209   /* Add the number of characters we actually converted.  */
210 #ifdef COUNT_CONVERTED
211   *converted += COUNT_CONVERTED;
212 #else
213   *converted += done;
214 #endif
215
216   /* Update the pointers pointed to by the parameters.  */
217   *inptrp = inptr;
218   *outptrp = outptr;
219
220   return result;
221 }
222
223
224 /* We remove the macro definitions so that we can include this file again
225    for the definition of another function.  */
226 #undef MIN_NEEDED_INPUT
227 #undef MAX_NEEDED_INPUT
228 #undef MIN_NEEDED_OUTPUT
229 #undef MAX_NEEDED_OUTPUT
230 #undef LOOPFCT
231 #undef COUNT_CONVERTED
232 #undef BODY
233 #undef LOOPFCT
234 #undef EXTRA_LOOP_DECLS