1 /* Skeleton for a conversion module.
2 Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
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 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; if not, write to the Free
18 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
21 /* This file can be included to provide definitions of several things
22 many modules have in common. It can be customized using the following
25 DEFINE_INIT define the default initializer. This requires the
26 following symbol to be defined.
28 CHARSET_NAME string with official name of the coded character
31 DEFINE_FINI define the default destructor function.
33 MIN_NEEDED_FROM minimal number of bytes needed for the from-charset.
34 MIN_NEEDED_TO likewise for the to-charset.
36 MAX_NEEDED_FROM maximal number of bytes needed for the from-charset.
37 This macro is optional, it defaults to MIN_NEEDED_FROM.
38 MAX_NEEDED_TO likewise for the to-charset.
40 FROM_LOOP_MIN_NEEDED_FROM
41 FROM_LOOP_MAX_NEEDED_FROM
42 minimal/maximal number of bytes needed on input
43 of one round through the FROM_LOOP. Defaults
44 to MIN_NEEDED_FROM and MAX_NEEDED_FROM, respectively.
45 FROM_LOOP_MIN_NEEDED_TO
46 FROM_LOOP_MAX_NEEDED_TO
47 minimal/maximal number of bytes needed on output
48 of one round through the FROM_LOOP. Defaults
49 to MIN_NEEDED_TO and MAX_NEEDED_TO, respectively.
50 TO_LOOP_MIN_NEEDED_FROM
51 TO_LOOP_MAX_NEEDED_FROM
52 minimal/maximal number of bytes needed on input
53 of one round through the TO_LOOP. Defaults
54 to MIN_NEEDED_TO and MAX_NEEDED_TO, respectively.
57 minimal/maximal number of bytes needed on output
58 of one round through the TO_LOOP. Defaults
59 to MIN_NEEDED_FROM and MAX_NEEDED_FROM, respectively.
61 DEFINE_DIRECTION_OBJECTS
62 two objects will be defined to be used when the
63 `gconv' function must only distinguish two
64 directions. This is implied by DEFINE_INIT.
65 If this macro is not defined the following
66 macro must be available.
68 FROM_DIRECTION this macro is supposed to return a value != 0
69 if we convert from the current character set,
70 otherwise it return 0.
72 EMIT_SHIFT_TO_INIT this symbol is optional. If it is defined it
73 defines some code which writes out a sequence
74 of bytes which bring the current state into
77 FROM_LOOP name of the function implementing the conversion
78 from the current character set.
79 TO_LOOP likewise for the other direction
81 ONE_DIRECTION optional. If defined to 1, only one conversion
82 direction is defined instead of two. In this
83 case, FROM_DIRECTION should be defined to 1, and
84 FROM_LOOP and TO_LOOP should have the same value.
86 SAVE_RESET_STATE in case of an error we must reset the state for
87 the rerun so this macro must be defined for
88 stateful encodings. It takes an argument which
89 is nonzero when saving.
91 RESET_INPUT_BUFFER If the input character sets allow this the macro
92 can be defined to reset the input buffer pointers
93 to cover only those characters up to the error.
95 FUNCTION_NAME if not set the conversion function is named `gconv'.
97 PREPARE_LOOP optional code preparing the conversion loop. Can
98 contain variable definitions.
99 END_LOOP also optional, may be used to store information
101 EXTRA_LOOP_ARGS optional macro specifying extra arguments passed
104 STORE_REST optional, needed only when MAX_NEEDED_FROM > 4.
105 This macro stores the seen but unconverted input bytes
108 FROM_ONEBYTE optional. If defined, should be the name of a
109 specialized conversion function for a single byte
110 from the current character set to INTERNAL. This
111 function has prototype
113 FROM_ONEBYTE (struct __gconv_step *, unsigned char);
114 and does a special conversion:
115 - The input is a single byte.
116 - The output is a single uint32_t.
117 - The state before the conversion is the initial state;
118 the state after the conversion is irrelevant.
119 - No transliteration.
120 - __invocation_counter = 0.
121 - __internal_use = 1.
124 Modules can use mbstate_t to store conversion state as follows:
126 * Bits 2..0 of '__count' contain the number of lookahead input bytes
127 stored in __value.__wchb. Always zero if the converter never
128 returns __GCONV_INCOMPLETE_INPUT.
130 * Bits 31..3 of '__count' are module dependent shift state.
132 * __value: When STORE_REST/UNPACK_BYTES aren't defined and when the
133 converter has returned __GCONV_INCOMPLETE_INPUT, this contains
134 at most 4 lookahead bytes. Converters with an mb_cur_max > 4
135 (currently only UTF-8) must find a way to store their state
136 in __value.__wch and define STORE_REST/UNPACK_BYTES appropriately.
138 When __value contains lookahead, __count must not be zero, because
139 the converter is not in the initial state then, and mbsinit() --
140 defined as a (__count == 0) test -- must reflect this.
146 #define __need_size_t
155 # define DL_CALL_FCT(fct, args) fct args
158 /* The direction objects. */
159 #if DEFINE_DIRECTION_OBJECTS || DEFINE_INIT
160 static int from_object;
161 static int to_object;
163 # ifndef FROM_DIRECTION
164 # define FROM_DIRECTION (step->__data == &from_object)
167 # ifndef FROM_DIRECTION
168 # error "FROM_DIRECTION must be provided if direction objects are not used"
173 /* How many bytes are needed at most for the from-charset. */
174 #ifndef MAX_NEEDED_FROM
175 # define MAX_NEEDED_FROM MIN_NEEDED_FROM
178 /* Same for the to-charset. */
179 #ifndef MAX_NEEDED_TO
180 # define MAX_NEEDED_TO MIN_NEEDED_TO
183 /* Defaults for the per-direction min/max constants. */
184 #ifndef FROM_LOOP_MIN_NEEDED_FROM
185 # define FROM_LOOP_MIN_NEEDED_FROM MIN_NEEDED_FROM
187 #ifndef FROM_LOOP_MAX_NEEDED_FROM
188 # define FROM_LOOP_MAX_NEEDED_FROM MAX_NEEDED_FROM
190 #ifndef FROM_LOOP_MIN_NEEDED_TO
191 # define FROM_LOOP_MIN_NEEDED_TO MIN_NEEDED_TO
193 #ifndef FROM_LOOP_MAX_NEEDED_TO
194 # define FROM_LOOP_MAX_NEEDED_TO MAX_NEEDED_TO
196 #ifndef TO_LOOP_MIN_NEEDED_FROM
197 # define TO_LOOP_MIN_NEEDED_FROM MIN_NEEDED_TO
199 #ifndef TO_LOOP_MAX_NEEDED_FROM
200 # define TO_LOOP_MAX_NEEDED_FROM MAX_NEEDED_TO
202 #ifndef TO_LOOP_MIN_NEEDED_TO
203 # define TO_LOOP_MIN_NEEDED_TO MIN_NEEDED_FROM
205 #ifndef TO_LOOP_MAX_NEEDED_TO
206 # define TO_LOOP_MAX_NEEDED_TO MAX_NEEDED_FROM
210 /* Define macros which can access unaligned buffers. These macros are
211 supposed to be used only in code outside the inner loops. For the inner
212 loops we have other definitions which allow optimized access. */
213 #ifdef _STRING_ARCH_unaligned
214 /* We can handle unaligned memory access. */
215 # define get16u(addr) *((__const uint16_t *) (addr))
216 # define get32u(addr) *((__const uint32_t *) (addr))
218 /* We need no special support for writing values either. */
219 # define put16u(addr, val) *((uint16_t *) (addr)) = (val)
220 # define put32u(addr, val) *((uint32_t *) (addr)) = (val)
222 /* Distinguish between big endian and little endian. */
223 # if __BYTE_ORDER == __LITTLE_ENDIAN
224 # define get16u(addr) \
225 (((__const unsigned char *) (addr))[1] << 8 \
226 | ((__const unsigned char *) (addr))[0])
227 # define get32u(addr) \
228 (((((__const unsigned char *) (addr))[3] << 8 \
229 | ((__const unsigned char *) (addr))[2]) << 8 \
230 | ((__const unsigned char *) (addr))[1]) << 8 \
231 | ((__const unsigned char *) (addr))[0])
233 # define put16u(addr, val) \
234 ({ uint16_t __val = (val); \
235 ((unsigned char *) (addr))[0] = __val; \
236 ((unsigned char *) (addr))[1] = __val >> 8; \
238 # define put32u(addr, val) \
239 ({ uint32_t __val = (val); \
240 ((unsigned char *) (addr))[0] = __val; \
242 ((unsigned char *) (addr))[1] = __val; \
244 ((unsigned char *) (addr))[2] = __val; \
246 ((unsigned char *) (addr))[3] = __val; \
249 # define get16u(addr) \
250 (((__const unsigned char *) (addr))[0] << 8 \
251 | ((__const unsigned char *) (addr))[1])
252 # define get32u(addr) \
253 (((((__const unsigned char *) (addr))[0] << 8 \
254 | ((__const unsigned char *) (addr))[1]) << 8 \
255 | ((__const unsigned char *) (addr))[2]) << 8 \
256 | ((__const unsigned char *) (addr))[3])
258 # define put16u(addr, val) \
259 ({ uint16_t __val = (val); \
260 ((unsigned char *) (addr))[1] = __val; \
261 ((unsigned char *) (addr))[0] = __val >> 8; \
263 # define put32u(addr, val) \
264 ({ uint32_t __val = (val); \
265 ((unsigned char *) (addr))[3] = __val; \
267 ((unsigned char *) (addr))[2] = __val; \
269 ((unsigned char *) (addr))[1] = __val; \
271 ((unsigned char *) (addr))[0] = __val; \
277 /* For conversions from a fixed width character set to another fixed width
278 character set we can define RESET_INPUT_BUFFER in a very fast way. */
279 #if !defined RESET_INPUT_BUFFER && !defined SAVE_RESET_STATE
280 # if FROM_LOOP_MIN_NEEDED_FROM == FROM_LOOP_MAX_NEEDED_FROM \
281 && FROM_LOOP_MIN_NEEDED_TO == FROM_LOOP_MAX_NEEDED_TO \
282 && TO_LOOP_MIN_NEEDED_FROM == TO_LOOP_MAX_NEEDED_FROM \
283 && TO_LOOP_MIN_NEEDED_TO == TO_LOOP_MAX_NEEDED_TO
284 /* We have to use these `if's here since the compiler cannot know that
285 (outbuf - outerr) is always divisible by FROM/TO_LOOP_MIN_NEEDED_TO.
286 The ?:1 avoids division by zero warnings that gcc 3.2 emits even for
287 obviously unreachable code. */
288 # define RESET_INPUT_BUFFER \
289 if (FROM_DIRECTION) \
291 if (FROM_LOOP_MIN_NEEDED_FROM % FROM_LOOP_MIN_NEEDED_TO == 0) \
292 *inptrp -= (outbuf - outerr) \
293 * (FROM_LOOP_MIN_NEEDED_FROM / FROM_LOOP_MIN_NEEDED_TO); \
294 else if (FROM_LOOP_MIN_NEEDED_TO % FROM_LOOP_MIN_NEEDED_FROM == 0) \
295 *inptrp -= (outbuf - outerr) \
296 / (FROM_LOOP_MIN_NEEDED_TO / FROM_LOOP_MIN_NEEDED_FROM \
299 *inptrp -= ((outbuf - outerr) / FROM_LOOP_MIN_NEEDED_TO) \
300 * FROM_LOOP_MIN_NEEDED_FROM; \
304 if (TO_LOOP_MIN_NEEDED_FROM % TO_LOOP_MIN_NEEDED_TO == 0) \
305 *inptrp -= (outbuf - outerr) \
306 * (TO_LOOP_MIN_NEEDED_FROM / TO_LOOP_MIN_NEEDED_TO); \
307 else if (TO_LOOP_MIN_NEEDED_TO % TO_LOOP_MIN_NEEDED_FROM == 0) \
308 *inptrp -= (outbuf - outerr) \
309 / (TO_LOOP_MIN_NEEDED_TO / TO_LOOP_MIN_NEEDED_FROM ? : 1); \
311 *inptrp -= ((outbuf - outerr) / TO_LOOP_MIN_NEEDED_TO) \
312 * TO_LOOP_MIN_NEEDED_FROM; \
318 /* The default init function. It simply matches the name and initializes
319 the step data to point to one of the objects above. */
321 # ifndef CHARSET_NAME
322 # error "CHARSET_NAME not defined"
325 extern int gconv_init (struct __gconv_step *step);
327 gconv_init (struct __gconv_step *step)
329 /* Determine which direction. */
330 if (strcmp (step->__from_name, CHARSET_NAME) == 0)
332 step->__data = &from_object;
334 step->__min_needed_from = FROM_LOOP_MIN_NEEDED_FROM;
335 step->__max_needed_from = FROM_LOOP_MAX_NEEDED_FROM;
336 step->__min_needed_to = FROM_LOOP_MIN_NEEDED_TO;
337 step->__max_needed_to = FROM_LOOP_MAX_NEEDED_TO;
340 step->__btowc_fct = FROM_ONEBYTE;
343 else if (__builtin_expect (strcmp (step->__to_name, CHARSET_NAME), 0) == 0)
345 step->__data = &to_object;
347 step->__min_needed_from = TO_LOOP_MIN_NEEDED_FROM;
348 step->__max_needed_from = TO_LOOP_MAX_NEEDED_FROM;
349 step->__min_needed_to = TO_LOOP_MIN_NEEDED_TO;
350 step->__max_needed_to = TO_LOOP_MAX_NEEDED_TO;
353 return __GCONV_NOCONV;
355 #ifdef SAVE_RESET_STATE
356 step->__stateful = 1;
358 step->__stateful = 0;
366 /* The default destructor function does nothing in the moment and so
367 we don't define it at all. But we still provide the macro just in
368 case we need it some day. */
373 /* If no arguments have to passed to the loop function define the macro
375 #ifndef EXTRA_LOOP_ARGS
376 # define EXTRA_LOOP_ARGS
380 /* This is the actual conversion function. */
381 #ifndef FUNCTION_NAME
382 # define FUNCTION_NAME gconv
385 /* The macros are used to access the function to convert single characters. */
386 #define SINGLE(fct) SINGLE2 (fct)
387 #define SINGLE2(fct) fct##_single
390 extern int FUNCTION_NAME (struct __gconv_step *step,
391 struct __gconv_step_data *data,
392 const unsigned char **inptrp,
393 const unsigned char *inend,
394 unsigned char **outbufstart, size_t *irreversible,
395 int do_flush, int consume_incomplete);
397 FUNCTION_NAME (struct __gconv_step *step, struct __gconv_step_data *data,
398 const unsigned char **inptrp, const unsigned char *inend,
399 unsigned char **outbufstart, size_t *irreversible, int do_flush,
400 int consume_incomplete)
402 struct __gconv_step *next_step = step + 1;
403 struct __gconv_step_data *next_data = data + 1;
407 fct = (data->__flags & __GCONV_IS_LAST) ? NULL : next_step->__fct;
409 /* If the function is called with no input this means we have to reset
410 to the initial state. The possibly partly converted input is
412 if (__builtin_expect (do_flush, 0))
414 /* This should never happen during error handling. */
415 assert (outbufstart == NULL);
419 #ifdef EMIT_SHIFT_TO_INIT
422 /* We preserve the initial values of the pointer variables. */
423 unsigned char *outbuf = data->__outbuf;
424 unsigned char *outstart = outbuf;
425 unsigned char *outend = data->__outbufend;
431 # ifdef SAVE_RESET_STATE
432 SAVE_RESET_STATE (1);
435 /* Emit the escape sequence to reset the state. */
438 /* Call the steps down the chain if there are any but only if we
439 successfully emitted the escape sequence. This should only
440 fail if the output buffer is full. If the input is invalid
441 it should be discarded since the user wants to start from a
443 if (status == __GCONV_OK)
445 if (data->__flags & __GCONV_IS_LAST)
446 /* Store information about how many bytes are available. */
447 data->__outbuf = outbuf;
450 /* Write out all output which was produced. */
451 if (outbuf > outstart)
453 const unsigned char *outerr = outstart;
456 result = DL_CALL_FCT (fct, (next_step, next_data,
457 &outerr, outbuf, NULL,
459 consume_incomplete));
461 if (result != __GCONV_EMPTY_INPUT)
463 if (__builtin_expect (outerr != outbuf, 0))
465 /* We have a problem. Undo the conversion. */
468 /* Restore the state. */
469 # ifdef SAVE_RESET_STATE
470 SAVE_RESET_STATE (0);
474 /* Change the status. */
479 if (status == __GCONV_OK)
480 /* Now flush the remaining steps. */
481 status = DL_CALL_FCT (fct, (next_step, next_data, NULL,
482 NULL, NULL, irreversible, 1,
483 consume_incomplete));
490 /* Clear the state object. There might be bytes in there from
491 previous calls with CONSUME_INCOMPLETE == 1. But don't emit
493 memset (data->__statep, '\0', sizeof (*data->__statep));
495 if (! (data->__flags & __GCONV_IS_LAST))
496 /* Now flush the remaining steps. */
497 status = DL_CALL_FCT (fct, (next_step, next_data, NULL, NULL,
498 NULL, irreversible, do_flush,
499 consume_incomplete));
504 /* We preserve the initial values of the pointer variables. */
505 const unsigned char *inptr = *inptrp;
506 unsigned char *outbuf = (__builtin_expect (outbufstart == NULL, 1)
507 ? data->__outbuf : *outbufstart);
508 unsigned char *outend = data->__outbufend;
509 unsigned char *outstart;
510 /* This variable is used to count the number of characters we
511 actually converted. */
512 size_t lirreversible = 0;
513 size_t *lirreversiblep = irreversible ? &lirreversible : NULL;
515 /* The following assumes that encodings, which have a variable length
516 what might unalign a buffer even though it is a aligned in the
517 beginning, either don't have the minimal number of bytes as a divisor
518 of the maximum length or have a minimum length of 1. This is true
519 for all known and supported encodings.
520 We use && instead of || to combine the subexpression for the FROM
521 encoding and for the TO encoding, because usually one of them is
522 INTERNAL, for which the subexpression evaluates to 1, but INTERNAL
523 buffers are always aligned correctly. */
524 #define POSSIBLY_UNALIGNED \
525 (!defined _STRING_ARCH_unaligned \
526 && (((FROM_LOOP_MIN_NEEDED_FROM != 1 \
527 && FROM_LOOP_MAX_NEEDED_FROM % FROM_LOOP_MIN_NEEDED_FROM == 0) \
528 && (FROM_LOOP_MIN_NEEDED_TO != 1 \
529 && FROM_LOOP_MAX_NEEDED_TO % FROM_LOOP_MIN_NEEDED_TO == 0)) \
530 || ((TO_LOOP_MIN_NEEDED_FROM != 1 \
531 && TO_LOOP_MAX_NEEDED_FROM % TO_LOOP_MIN_NEEDED_FROM == 0) \
532 && (TO_LOOP_MIN_NEEDED_TO != 1 \
533 && TO_LOOP_MAX_NEEDED_TO % TO_LOOP_MIN_NEEDED_TO == 0))))
534 #if POSSIBLY_UNALIGNED
536 # define GEN_unaligned(name) GEN_unaligned2 (name)
537 # define GEN_unaligned2(name) name##_unaligned
546 #if FROM_LOOP_MAX_NEEDED_FROM > 1 || TO_LOOP_MAX_NEEDED_FROM > 1
547 /* If the function is used to implement the mb*towc*() or wc*tomb*()
548 functions we must test whether any bytes from the last call are
549 stored in the `state' object. */
550 if (((FROM_LOOP_MAX_NEEDED_FROM > 1 && TO_LOOP_MAX_NEEDED_FROM > 1)
551 || (FROM_LOOP_MAX_NEEDED_FROM > 1 && FROM_DIRECTION)
552 || (TO_LOOP_MAX_NEEDED_FROM > 1 && !FROM_DIRECTION))
553 && consume_incomplete && (data->__statep->__count & 7) != 0)
555 /* Yep, we have some bytes left over. Process them now.
556 But this must not happen while we are called from an
558 assert (outbufstart == NULL);
560 # if FROM_LOOP_MAX_NEEDED_FROM > 1
561 if (TO_LOOP_MAX_NEEDED_FROM == 1 || FROM_DIRECTION)
562 status = SINGLE(FROM_LOOP) (step, data, inptrp, inend, &outbuf,
563 outend, lirreversiblep
567 # if FROM_LOOP_MAX_NEEDED_FROM > 1 && TO_LOOP_MAX_NEEDED_FROM > 1
570 # if TO_LOOP_MAX_NEEDED_FROM > 1
571 status = SINGLE(TO_LOOP) (step, data, inptrp, inend, &outbuf,
572 outend, lirreversiblep EXTRA_LOOP_ARGS);
576 if (__builtin_expect (status, __GCONV_OK) != __GCONV_OK)
581 #if POSSIBLY_UNALIGNED
584 && ((uintptr_t) inptr % FROM_LOOP_MIN_NEEDED_FROM != 0
585 || ((data->__flags & __GCONV_IS_LAST)
586 && (uintptr_t) outbuf % FROM_LOOP_MIN_NEEDED_TO != 0)))
588 && (((data->__flags & __GCONV_IS_LAST)
589 && (uintptr_t) outbuf % TO_LOOP_MIN_NEEDED_TO != 0)
590 || (uintptr_t) inptr % TO_LOOP_MIN_NEEDED_FROM != 0)));
595 struct __gconv_trans_data *trans;
597 /* Remember the start value for this round. */
599 /* The outbuf buffer is empty. */
602 #ifdef SAVE_RESET_STATE
603 SAVE_RESET_STATE (1);
606 if (__builtin_expect (!unaligned, 1))
609 /* Run the conversion loop. */
610 status = FROM_LOOP (step, data, inptrp, inend, &outbuf, outend,
611 lirreversiblep EXTRA_LOOP_ARGS);
613 /* Run the conversion loop. */
614 status = TO_LOOP (step, data, inptrp, inend, &outbuf, outend,
615 lirreversiblep EXTRA_LOOP_ARGS);
617 #if POSSIBLY_UNALIGNED
621 /* Run the conversion loop. */
622 status = GEN_unaligned (FROM_LOOP) (step, data, inptrp, inend,
627 /* Run the conversion loop. */
628 status = GEN_unaligned (TO_LOOP) (step, data, inptrp, inend,
635 /* If we were called as part of an error handling module we
636 don't do anything else here. */
637 if (__builtin_expect (outbufstart != NULL, 0))
639 *outbufstart = outbuf;
643 /* Give the transliteration module the chance to store the
644 original text and the result in case it needs a context. */
645 for (trans = data->__trans; trans != NULL; trans = trans->__next)
646 if (trans->__trans_context_fct != NULL)
647 DL_CALL_FCT (trans->__trans_context_fct,
648 (trans->__data, inptr, *inptrp, outstart, outbuf));
650 /* We finished one use of the loops. */
651 ++data->__invocation_counter;
653 /* If this is the last step leave the loop, there is nothing
655 if (__builtin_expect (data->__flags & __GCONV_IS_LAST, 0))
657 /* Store information about how many bytes are available. */
658 data->__outbuf = outbuf;
660 /* Remember how many non-identical characters we
661 converted in a irreversible way. */
662 *irreversible += lirreversible;
667 /* Write out all output which was produced. */
668 if (__builtin_expect (outbuf > outstart, 1))
670 const unsigned char *outerr = data->__outbuf;
673 result = DL_CALL_FCT (fct, (next_step, next_data, &outerr,
674 outbuf, NULL, irreversible, 0,
675 consume_incomplete));
677 if (result != __GCONV_EMPTY_INPUT)
679 if (__builtin_expect (outerr != outbuf, 0))
681 #ifdef RESET_INPUT_BUFFER
684 /* We have a problem with the in on of the functions
685 below. Undo the conversion upto the error point. */
688 /* Reload the pointers. */
692 /* Restore the state. */
693 # ifdef SAVE_RESET_STATE
694 SAVE_RESET_STATE (0);
697 if (__builtin_expect (!unaligned, 1))
700 /* Run the conversion loop. */
701 nstatus = FROM_LOOP (step, data, inptrp, inend,
706 /* Run the conversion loop. */
707 nstatus = TO_LOOP (step, data, inptrp, inend,
712 # if POSSIBLY_UNALIGNED
716 /* Run the conversion loop. */
717 nstatus = GEN_unaligned (FROM_LOOP) (step, data,
724 /* Run the conversion loop. */
725 nstatus = GEN_unaligned (TO_LOOP) (step, data,
733 /* We must run out of output buffer space in this
735 assert (outbuf == outerr);
736 assert (nstatus == __GCONV_FULL_OUTPUT);
738 /* If we haven't consumed a single byte decrement
739 the invocation counter. */
740 if (__builtin_expect (outbuf == outstart, 0))
741 --data->__invocation_counter;
742 #endif /* reset input buffer */
745 /* Change the status. */
749 /* All the output is consumed, we can make another run
750 if everything was ok. */
751 if (status == __GCONV_FULL_OUTPUT)
754 outbuf = data->__outbuf;
758 if (status != __GCONV_OK)
761 /* Reset the output buffer pointer for the next round. */
762 outbuf = data->__outbuf;
769 /* If we are supposed to consume all character store now all of the
770 remaining characters in the `state' object. */
771 #if FROM_LOOP_MAX_NEEDED_FROM > 1 || TO_LOOP_MAX_NEEDED_FROM > 1
772 if (((FROM_LOOP_MAX_NEEDED_FROM > 1 && TO_LOOP_MAX_NEEDED_FROM > 1)
773 || (FROM_LOOP_MAX_NEEDED_FROM > 1 && FROM_DIRECTION)
774 || (TO_LOOP_MAX_NEEDED_FROM > 1 && !FROM_DIRECTION))
775 && __builtin_expect (consume_incomplete, 0)
776 && status == __GCONV_INCOMPLETE_INPUT)
779 mbstate_t *state = data->__statep;
785 /* Make sure the remaining bytes fit into the state objects
787 assert (inend - *inptrp < 4);
789 for (cnt = 0; *inptrp < inend; ++cnt)
790 data->__statep->__value.__wchb[cnt] = *(*inptrp)++;
791 data->__statep->__count &= ~7;
792 data->__statep->__count |= cnt;
797 #undef POSSIBLY_UNALIGNED
806 #undef MIN_NEEDED_FROM
808 #undef MAX_NEEDED_FROM
810 #undef FROM_LOOP_MIN_NEEDED_FROM
811 #undef FROM_LOOP_MAX_NEEDED_FROM
812 #undef FROM_LOOP_MIN_NEEDED_TO
813 #undef FROM_LOOP_MAX_NEEDED_TO
814 #undef TO_LOOP_MIN_NEEDED_FROM
815 #undef TO_LOOP_MAX_NEEDED_FROM
816 #undef TO_LOOP_MIN_NEEDED_TO
817 #undef TO_LOOP_MAX_NEEDED_TO
818 #undef DEFINE_DIRECTION_OBJECTS
819 #undef FROM_DIRECTION
820 #undef EMIT_SHIFT_TO_INIT
824 #undef SAVE_RESET_STATE
825 #undef RESET_INPUT_BUFFER
829 #undef EXTRA_LOOP_ARGS