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