1 /* Skeleton for a conversion module.
2 Copyright (C) 1998-2023 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <https://www.gnu.org/licenses/>. */
18
19 /* This file can be included to provide definitions of several things
20 many modules have in common. It can be customized using the following
21 macros:
22
23 DEFINE_INIT define the default initializer. This requires the
24 following symbol to be defined.
25
26 CHARSET_NAME string with official name of the coded character
27 set (in all-caps)
28
29 DEFINE_FINI define the default destructor function.
30
31 MIN_NEEDED_FROM minimal number of bytes needed for the from-charset.
32 MIN_NEEDED_TO likewise for the to-charset.
33
34 MAX_NEEDED_FROM maximal number of bytes needed for the from-charset.
35 This macro is optional, it defaults to MIN_NEEDED_FROM.
36 MAX_NEEDED_TO likewise for the to-charset.
37
38 FROM_LOOP_MIN_NEEDED_FROM
39 FROM_LOOP_MAX_NEEDED_FROM
40 minimal/maximal number of bytes needed on input
41 of one round through the FROM_LOOP. Defaults
42 to MIN_NEEDED_FROM and MAX_NEEDED_FROM, respectively.
43 FROM_LOOP_MIN_NEEDED_TO
44 FROM_LOOP_MAX_NEEDED_TO
45 minimal/maximal number of bytes needed on output
46 of one round through the FROM_LOOP. Defaults
47 to MIN_NEEDED_TO and MAX_NEEDED_TO, respectively.
48 TO_LOOP_MIN_NEEDED_FROM
49 TO_LOOP_MAX_NEEDED_FROM
50 minimal/maximal number of bytes needed on input
51 of one round through the TO_LOOP. Defaults
52 to MIN_NEEDED_TO and MAX_NEEDED_TO, respectively.
53 TO_LOOP_MIN_NEEDED_TO
54 TO_LOOP_MAX_NEEDED_TO
55 minimal/maximal number of bytes needed on output
56 of one round through the TO_LOOP. Defaults
57 to MIN_NEEDED_FROM and MAX_NEEDED_FROM, respectively.
58
59 FROM_DIRECTION this macro is supposed to return a value != 0
60 if we convert from the current character set,
61 otherwise it return 0.
62
63 EMIT_SHIFT_TO_INIT this symbol is optional. If it is defined it
64 defines some code which writes out a sequence
65 of bytes which bring the current state into
66 the initial state.
67
68 FROM_LOOP name of the function implementing the conversion
69 from the current character set.
70 TO_LOOP likewise for the other direction
71
72 ONE_DIRECTION optional. If defined to 1, only one conversion
73 direction is defined instead of two. In this
74 case, FROM_DIRECTION should be defined to 1, and
75 FROM_LOOP and TO_LOOP should have the same value.
76
77 SAVE_RESET_STATE in case of an error we must reset the state for
78 the rerun so this macro must be defined for
79 stateful encodings. It takes an argument which
80 is nonzero when saving.
81
82 RESET_INPUT_BUFFER If the input character sets allow this the macro
83 can be defined to reset the input buffer pointers
84 to cover only those characters up to the error.
85 Note that if the conversion has skipped over
86 irreversible characters (due to
87 __GCONV_IGNORE_ERRORS) there is no longer a direct
88 correspondence between input and output pointers,
89 and this macro is not called.
90
91 FUNCTION_NAME if not set the conversion function is named `gconv'.
92
93 PREPARE_LOOP optional code preparing the conversion loop. Can
94 contain variable definitions.
95 END_LOOP also optional, may be used to store information
96
97 EXTRA_LOOP_ARGS optional macro specifying extra arguments passed
98 to loop function.
99
100 STORE_REST optional, needed only when MAX_NEEDED_FROM > 4.
101 This macro stores the seen but unconverted input bytes
102 in the state.
103
104 FROM_ONEBYTE optional. If defined, should be the name of a
105 specialized conversion function for a single byte
106 from the current character set to INTERNAL. This
107 function has prototype
108 wint_t
109 FROM_ONEBYTE (struct __gconv_step *, unsigned char);
110 and does a special conversion:
111 - The input is a single byte.
112 - The output is a single uint32_t.
113 - The state before the conversion is the initial state;
114 the state after the conversion is irrelevant.
115 - No transliteration.
116 - __invocation_counter = 0.
117 - __internal_use = 1.
118 - do_flush = 0.
119
120 Modules can use mbstate_t to store conversion state as follows:
121
122 * Bits 2..0 of '__count' contain the number of lookahead input bytes
123 stored in __value.__wchb. Always zero if the converter never
124 returns __GCONV_INCOMPLETE_INPUT.
125
126 * Bits 31..3 of '__count' are module dependent shift state.
127
128 * __value: When STORE_REST/UNPACK_BYTES aren't defined and when the
129 converter has returned __GCONV_INCOMPLETE_INPUT, this contains
130 at most 4 lookahead bytes. Converters with an mb_cur_max > 4
131 (currently only UTF-8) must find a way to store their state
132 in __value.__wch and define STORE_REST/UNPACK_BYTES appropriately.
133
134 When __value contains lookahead, __count must not be zero, because
135 the converter is not in the initial state then, and mbsinit() --
136 defined as a (__count == 0) test -- must reflect this.
137 */
138
139 #include <assert.h>
140 #include <iconv/gconv_int.h>
141 #include <string.h>
142 #define __need_size_t
143 #define __need_NULL
144 #include <stddef.h>
145
146 #ifndef STATIC_GCONV
147 # include <dlfcn.h>
148 #endif
149
150 #include <pointer_guard.h>
151 #include <stdint.h>
152
153 #ifndef DL_CALL_FCT
154 # define DL_CALL_FCT(fct, args) fct args
155 #endif
156
157 /* The direction objects. */
158 #if DEFINE_INIT
159 # ifndef FROM_DIRECTION
160 # define FROM_DIRECTION_VAL NULL
161 # define TO_DIRECTION_VAL ((void *) ~((uintptr_t) 0))
162 # define FROM_DIRECTION (step->__data == FROM_DIRECTION_VAL)
163 # endif
164 #else
165 # ifndef FROM_DIRECTION
166 # error "FROM_DIRECTION must be provided if non-default init is used"
167 # endif
168 #endif
169
170 /* How many bytes are needed at most for the from-charset. */
171 #ifndef MAX_NEEDED_FROM
172 # define MAX_NEEDED_FROM MIN_NEEDED_FROM
173 #endif
174
175 /* Same for the to-charset. */
176 #ifndef MAX_NEEDED_TO
177 # define MAX_NEEDED_TO MIN_NEEDED_TO
178 #endif
179
180 /* Defaults for the per-direction min/max constants. */
181 #ifndef FROM_LOOP_MIN_NEEDED_FROM
182 # define FROM_LOOP_MIN_NEEDED_FROM MIN_NEEDED_FROM
183 #endif
184 #ifndef FROM_LOOP_MAX_NEEDED_FROM
185 # define FROM_LOOP_MAX_NEEDED_FROM MAX_NEEDED_FROM
186 #endif
187 #ifndef FROM_LOOP_MIN_NEEDED_TO
188 # define FROM_LOOP_MIN_NEEDED_TO MIN_NEEDED_TO
189 #endif
190 #ifndef FROM_LOOP_MAX_NEEDED_TO
191 # define FROM_LOOP_MAX_NEEDED_TO MAX_NEEDED_TO
192 #endif
193 #ifndef TO_LOOP_MIN_NEEDED_FROM
194 # define TO_LOOP_MIN_NEEDED_FROM MIN_NEEDED_TO
195 #endif
196 #ifndef TO_LOOP_MAX_NEEDED_FROM
197 # define TO_LOOP_MAX_NEEDED_FROM MAX_NEEDED_TO
198 #endif
199 #ifndef TO_LOOP_MIN_NEEDED_TO
200 # define TO_LOOP_MIN_NEEDED_TO MIN_NEEDED_FROM
201 #endif
202 #ifndef TO_LOOP_MAX_NEEDED_TO
203 # define TO_LOOP_MAX_NEEDED_TO MAX_NEEDED_FROM
204 #endif
205
206
207 /* For conversions from a fixed width character set to another fixed width
208 character set we can define RESET_INPUT_BUFFER in a very fast way. */
209 #if !defined RESET_INPUT_BUFFER && !defined SAVE_RESET_STATE
210 # if FROM_LOOP_MIN_NEEDED_FROM == FROM_LOOP_MAX_NEEDED_FROM \
211 && FROM_LOOP_MIN_NEEDED_TO == FROM_LOOP_MAX_NEEDED_TO \
212 && TO_LOOP_MIN_NEEDED_FROM == TO_LOOP_MAX_NEEDED_FROM \
213 && TO_LOOP_MIN_NEEDED_TO == TO_LOOP_MAX_NEEDED_TO
214 /* We have to use these `if's here since the compiler cannot know that
215 (outbuf - outerr) is always divisible by FROM/TO_LOOP_MIN_NEEDED_TO.
216 The ?:1 avoids division by zero warnings that gcc 3.2 emits even for
217 obviously unreachable code. */
218 # define RESET_INPUT_BUFFER \
219 if (FROM_DIRECTION) \
220 { \
221 if (FROM_LOOP_MIN_NEEDED_FROM % FROM_LOOP_MIN_NEEDED_TO == 0) \
222 *inptrp -= (outbuf - outerr) \
223 * (FROM_LOOP_MIN_NEEDED_FROM / FROM_LOOP_MIN_NEEDED_TO); \
224 else if (FROM_LOOP_MIN_NEEDED_TO % FROM_LOOP_MIN_NEEDED_FROM == 0) \
225 *inptrp -= (outbuf - outerr) \
226 / (FROM_LOOP_MIN_NEEDED_TO / FROM_LOOP_MIN_NEEDED_FROM \
227 ? : 1); \
228 else \
229 *inptrp -= ((outbuf - outerr) / FROM_LOOP_MIN_NEEDED_TO) \
230 * FROM_LOOP_MIN_NEEDED_FROM; \
231 } \
232 else \
233 { \
234 if (TO_LOOP_MIN_NEEDED_FROM % TO_LOOP_MIN_NEEDED_TO == 0) \
235 *inptrp -= (outbuf - outerr) \
236 * (TO_LOOP_MIN_NEEDED_FROM / TO_LOOP_MIN_NEEDED_TO); \
237 else if (TO_LOOP_MIN_NEEDED_TO % TO_LOOP_MIN_NEEDED_FROM == 0) \
238 *inptrp -= (outbuf - outerr) \
239 / (TO_LOOP_MIN_NEEDED_TO / TO_LOOP_MIN_NEEDED_FROM ? : 1); \
240 else \
241 *inptrp -= ((outbuf - outerr) / TO_LOOP_MIN_NEEDED_TO) \
242 * TO_LOOP_MIN_NEEDED_FROM; \
243 }
244 # endif
245 #endif
246
247
248 /* The default init function. It simply matches the name and initializes
249 the step data to point to one of the objects above. */
250 #if DEFINE_INIT
251 # ifndef CHARSET_NAME
252 # error "CHARSET_NAME not defined"
253 # endif
254
255 extern int gconv_init (struct __gconv_step *step);
256 int
257 gconv_init (struct __gconv_step *step)
258 {
259 /* Determine which direction. */
260 if (strcmp (step->__from_name, CHARSET_NAME) == 0)
261 {
262 step->__data = FROM_DIRECTION_VAL;
263
264 step->__min_needed_from = FROM_LOOP_MIN_NEEDED_FROM;
265 step->__max_needed_from = FROM_LOOP_MAX_NEEDED_FROM;
266 step->__min_needed_to = FROM_LOOP_MIN_NEEDED_TO;
267 step->__max_needed_to = FROM_LOOP_MAX_NEEDED_TO;
268
269 #ifdef FROM_ONEBYTE
270 step->__btowc_fct = FROM_ONEBYTE;
271 #endif
272 }
273 else if (__builtin_expect (strcmp (step->__to_name, CHARSET_NAME), 0) == 0)
274 {
275 step->__data = TO_DIRECTION_VAL;
276
277 step->__min_needed_from = TO_LOOP_MIN_NEEDED_FROM;
278 step->__max_needed_from = TO_LOOP_MAX_NEEDED_FROM;
279 step->__min_needed_to = TO_LOOP_MIN_NEEDED_TO;
280 step->__max_needed_to = TO_LOOP_MAX_NEEDED_TO;
281 }
282 else
283 return __GCONV_NOCONV;
284
285 #ifdef SAVE_RESET_STATE
286 step->__stateful = 1;
287 #else
288 step->__stateful = 0;
289 #endif
290
291 return __GCONV_OK;
292 }
293 #endif
294
295
296 /* The default destructor function does nothing in the moment and so
297 we don't define it at all. But we still provide the macro just in
298 case we need it some day. */
299 #if DEFINE_FINI
300 #endif
301
302
303 /* If no arguments have to passed to the loop function define the macro
304 as empty. */
305 #ifndef EXTRA_LOOP_ARGS
306 # define EXTRA_LOOP_ARGS
307 #endif
308
309
310 /* This is the actual conversion function. */
311 #ifndef FUNCTION_NAME
312 # define FUNCTION_NAME gconv
313 #endif
314
315 /* The macros are used to access the function to convert single characters. */
316 #define SINGLE(fct) SINGLE2 (fct)
317 #define SINGLE2(fct) fct##_single
318
319
320 extern int FUNCTION_NAME (struct __gconv_step *step,
321 struct __gconv_step_data *data,
322 const unsigned char **inptrp,
323 const unsigned char *inend,
324 unsigned char **outbufstart, size_t *irreversible,
325 int do_flush, int consume_incomplete);
326 int
327 FUNCTION_NAME (struct __gconv_step *step, struct __gconv_step_data *data,
328 const unsigned char **inptrp, const unsigned char *inend,
329 unsigned char **outbufstart, size_t *irreversible, int do_flush,
330 int consume_incomplete)
331 {
332 struct __gconv_step *next_step = step + 1;
333 struct __gconv_step_data *next_data = data + 1;
334 __gconv_fct fct = NULL;
335 int status;
336
337 if ((data->__flags & __GCONV_IS_LAST) == 0)
338 {
339 fct = next_step->__fct;
340 if (next_step->__shlib_handle != NULL)
341 PTR_DEMANGLE (fct);
342 }
343
344 /* If the function is called with no input this means we have to reset
345 to the initial state. The possibly partly converted input is
346 dropped. */
347 if (__glibc_unlikely (do_flush))
348 {
349 /* This should never happen during error handling. */
350 assert (outbufstart == NULL);
351
352 status = __GCONV_OK;
353
354 #ifdef EMIT_SHIFT_TO_INIT
355 if (do_flush == 1)
356 {
357 /* We preserve the initial values of the pointer variables. */
358 unsigned char *outbuf = data->__outbuf;
359 unsigned char *outstart = outbuf;
360 unsigned char *outend = data->__outbufend;
361
362 # ifdef PREPARE_LOOP
363 PREPARE_LOOP
364 # endif
365
366 # ifdef SAVE_RESET_STATE
367 SAVE_RESET_STATE (1);
368 # endif
369
370 /* Emit the escape sequence to reset the state. */
371 EMIT_SHIFT_TO_INIT;
372
373 /* Call the steps down the chain if there are any but only if we
374 successfully emitted the escape sequence. This should only
375 fail if the output buffer is full. If the input is invalid
376 it should be discarded since the user wants to start from a
377 clean state. */
378 if (status == __GCONV_OK)
379 {
380 if (data->__flags & __GCONV_IS_LAST)
381 /* Store information about how many bytes are available. */
382 data->__outbuf = outbuf;
383 else
384 {
385 /* Write out all output which was produced. */
386 if (outbuf > outstart)
387 {
388 const unsigned char *outerr = outstart;
389 int result;
390
391 result = DL_CALL_FCT (fct, (next_step, next_data,
392 &outerr, outbuf, NULL,
393 irreversible, 0,
394 consume_incomplete));
395
396 if (result != __GCONV_EMPTY_INPUT)
397 {
398 if (__glibc_unlikely (outerr != outbuf))
399 {
400 /* We have a problem. Undo the conversion. */
401 outbuf = outstart;
402
403 /* Restore the state. */
404 # ifdef SAVE_RESET_STATE
405 SAVE_RESET_STATE (0);
406 # endif
407 }
408
409 /* Change the status. */
410 status = result;
411 }
412 }
413
414 if (status == __GCONV_OK)
415 /* Now flush the remaining steps. */
416 status = DL_CALL_FCT (fct, (next_step, next_data, NULL,
417 NULL, NULL, irreversible, 1,
418 consume_incomplete));
419 }
420 }
421 }
422 else
423 #endif
424 {
425 /* Clear the state object. There might be bytes in there from
426 previous calls with CONSUME_INCOMPLETE == 1. But don't emit
427 escape sequences. */
428 memset (data->__statep, '\0', sizeof (*data->__statep));
429
430 if (! (data->__flags & __GCONV_IS_LAST))
431 /* Now flush the remaining steps. */
432 status = DL_CALL_FCT (fct, (next_step, next_data, NULL, NULL,
433 NULL, irreversible, do_flush,
434 consume_incomplete));
435 }
436 }
437 else
438 {
439 /* We preserve the initial values of the pointer variables,
440 but only some conversion modules need it. */
441 const unsigned char *inptr __attribute__ ((__unused__)) = *inptrp;
442 unsigned char *outbuf = (__builtin_expect (outbufstart == NULL, 1)
443 ? data->__outbuf : *outbufstart);
444 unsigned char *outend = data->__outbufend;
445 unsigned char *outstart;
446 /* This variable is used to count the number of characters we
447 actually converted. */
448 size_t lirreversible = 0;
449 size_t *lirreversiblep = irreversible ? &lirreversible : NULL;
450
451 #ifdef PREPARE_LOOP
452 PREPARE_LOOP
453 #endif
454
455 #if FROM_LOOP_MAX_NEEDED_FROM > 1 || TO_LOOP_MAX_NEEDED_FROM > 1
456 /* If the function is used to implement the mb*towc*() or wc*tomb*()
457 functions we must test whether any bytes from the last call are
458 stored in the `state' object. */
459 if (((FROM_LOOP_MAX_NEEDED_FROM > 1 && TO_LOOP_MAX_NEEDED_FROM > 1)
460 || (FROM_LOOP_MAX_NEEDED_FROM > 1 && FROM_DIRECTION)
461 || (TO_LOOP_MAX_NEEDED_FROM > 1 && !FROM_DIRECTION))
462 && consume_incomplete && (data->__statep->__count & 7) != 0)
463 {
464 /* Yep, we have some bytes left over. Process them now.
465 But this must not happen while we are called from an
466 error handler. */
467 assert (outbufstart == NULL);
468
469 # if FROM_LOOP_MAX_NEEDED_FROM > 1
470 if (TO_LOOP_MAX_NEEDED_FROM == 1 || FROM_DIRECTION)
471 status = SINGLE(FROM_LOOP) (step, data, inptrp, inend, &outbuf,
472 outend, lirreversiblep
473 EXTRA_LOOP_ARGS);
474 # endif
475 # if !ONE_DIRECTION
476 # if FROM_LOOP_MAX_NEEDED_FROM > 1 && TO_LOOP_MAX_NEEDED_FROM > 1
477 else
478 # endif
479 # if TO_LOOP_MAX_NEEDED_FROM > 1
480 status = SINGLE(TO_LOOP) (step, data, inptrp, inend, &outbuf,
481 outend, lirreversiblep EXTRA_LOOP_ARGS);
482 # endif
483 # endif
484
485 if (__builtin_expect (status, __GCONV_OK) != __GCONV_OK)
486 return status;
487 }
488 #endif
489
490 while (1)
491 {
492 /* Remember the start value for this round. */
493 inptr = *inptrp;
494 /* The outbuf buffer is empty. */
495 outstart = outbuf;
496 #ifdef RESET_INPUT_BUFFER
497 /* Remember how many irreversible characters were skipped before
498 this round. */
499 size_t loop_irreversible
500 = lirreversible + (irreversible ? *irreversible : 0);
501 #endif
502
503 #ifdef SAVE_RESET_STATE
504 SAVE_RESET_STATE (1);
505 #endif
506
507 if (FROM_DIRECTION)
508 /* Run the conversion loop. */
509 status = FROM_LOOP (step, data, inptrp, inend, &outbuf, outend,
510 lirreversiblep EXTRA_LOOP_ARGS);
511 else
512 /* Run the conversion loop. */
513 status = TO_LOOP (step, data, inptrp, inend, &outbuf, outend,
514 lirreversiblep EXTRA_LOOP_ARGS);
515
516 /* If we were called as part of an error handling module we
517 don't do anything else here. */
518 if (__glibc_unlikely (outbufstart != NULL))
519 {
520 *outbufstart = outbuf;
521 return status;
522 }
523
524 /* We finished one use of the loops. */
525 ++data->__invocation_counter;
526
527 /* If this is the last step leave the loop, there is nothing
528 we can do. */
529 if (__glibc_unlikely (data->__flags & __GCONV_IS_LAST))
530 {
531 /* Store information about how many bytes are available. */
532 data->__outbuf = outbuf;
533
534 /* Remember how many non-identical characters we
535 converted in an irreversible way. */
536 *irreversible += lirreversible;
537
538 break;
539 }
540
541 /* Write out all output which was produced. */
542 if (__glibc_likely (outbuf > outstart))
543 {
544 const unsigned char *outerr = data->__outbuf;
545 int result;
546
547 result = DL_CALL_FCT (fct, (next_step, next_data, &outerr,
548 outbuf, NULL, irreversible, 0,
549 consume_incomplete));
550
551 if (result != __GCONV_EMPTY_INPUT)
552 {
553 if (__glibc_unlikely (outerr != outbuf))
554 {
555 #ifdef RESET_INPUT_BUFFER
556 /* RESET_INPUT_BUFFER can only work when there were
557 no new irreversible characters skipped during
558 this round. */
559 if (loop_irreversible
560 == lirreversible + (irreversible ? *irreversible : 0))
561 {
562 RESET_INPUT_BUFFER;
563 goto done_reset;
564 }
565 #endif
566 /* We have a problem in one of the functions below.
567 Undo the conversion upto the error point. */
568 size_t nstatus __attribute__ ((unused));
569
570 /* Reload the pointers. */
571 *inptrp = inptr;
572 outbuf = outstart;
573
574 /* Restore the state. */
575 #ifdef SAVE_RESET_STATE
576 SAVE_RESET_STATE (0);
577 #endif
578
579 if (FROM_DIRECTION)
580 /* Run the conversion loop. */
581 nstatus = FROM_LOOP (step, data, inptrp, inend,
582 &outbuf, outerr,
583 lirreversiblep
584 EXTRA_LOOP_ARGS);
585 else
586 /* Run the conversion loop. */
587 nstatus = TO_LOOP (step, data, inptrp, inend,
588 &outbuf, outerr,
589 lirreversiblep
590 EXTRA_LOOP_ARGS);
591
592 /* We must run out of output buffer space in this
593 rerun. */
594 assert (outbuf == outerr);
595 assert (nstatus == __GCONV_FULL_OUTPUT);
596
597 /* If we haven't consumed a single byte decrement
598 the invocation counter. */
599 if (__glibc_unlikely (outbuf == outstart))
600 --data->__invocation_counter;
601 }
602
603 #ifdef RESET_INPUT_BUFFER
604 done_reset:
605 #endif
606 /* Change the status. */
607 status = result;
608 }
609 else
610 /* All the output is consumed, we can make another run
611 if everything was ok. */
612 if (status == __GCONV_FULL_OUTPUT)
613 {
614 status = __GCONV_OK;
615 outbuf = data->__outbuf;
616 }
617 }
618
619 if (status != __GCONV_OK)
620 break;
621
622 /* Reset the output buffer pointer for the next round. */
623 outbuf = data->__outbuf;
624 }
625
626 #ifdef END_LOOP
627 END_LOOP
628 #endif
629
630 /* If we are supposed to consume all character store now all of the
631 remaining characters in the `state' object. */
632 #if FROM_LOOP_MAX_NEEDED_FROM > 1 || TO_LOOP_MAX_NEEDED_FROM > 1
633 if (((FROM_LOOP_MAX_NEEDED_FROM > 1 && TO_LOOP_MAX_NEEDED_FROM > 1)
634 || (FROM_LOOP_MAX_NEEDED_FROM > 1 && FROM_DIRECTION)
635 || (TO_LOOP_MAX_NEEDED_FROM > 1 && !FROM_DIRECTION))
636 && __builtin_expect (consume_incomplete, 0)
637 && status == __GCONV_INCOMPLETE_INPUT)
638 {
639 # ifdef STORE_REST
640 mbstate_t *state = data->__statep;
641
642 STORE_REST
643 # else
644 /* Make sure the remaining bytes fit into the state objects
645 buffer. */
646 size_t cnt_after = inend - *inptrp;
647 assert (cnt_after <= sizeof (data->__statep->__value.__wchb));
648
649 size_t cnt;
650 for (cnt = 0; cnt < cnt_after; ++cnt)
651 data->__statep->__value.__wchb[cnt] = (*inptrp)[cnt];
652 *inptrp = inend;
653 data->__statep->__count &= ~7;
654 data->__statep->__count |= cnt;
655 # endif
656 }
657 #endif
658 #undef unaligned
659 #undef POSSIBLY_UNALIGNED
660 }
661
662 return status;
663 }
664
665 #undef DEFINE_INIT
666 #undef CHARSET_NAME
667 #undef DEFINE_FINI
668 #undef MIN_NEEDED_FROM
669 #undef MIN_NEEDED_TO
670 #undef MAX_NEEDED_FROM
671 #undef MAX_NEEDED_TO
672 #undef FROM_LOOP_MIN_NEEDED_FROM
673 #undef FROM_LOOP_MAX_NEEDED_FROM
674 #undef FROM_LOOP_MIN_NEEDED_TO
675 #undef FROM_LOOP_MAX_NEEDED_TO
676 #undef TO_LOOP_MIN_NEEDED_FROM
677 #undef TO_LOOP_MAX_NEEDED_FROM
678 #undef TO_LOOP_MIN_NEEDED_TO
679 #undef TO_LOOP_MAX_NEEDED_TO
680 #undef FROM_DIRECTION
681 #undef EMIT_SHIFT_TO_INIT
682 #undef FROM_LOOP
683 #undef TO_LOOP
684 #undef ONE_DIRECTION
685 #undef SAVE_RESET_STATE
686 #undef RESET_INPUT_BUFFER
687 #undef FUNCTION_NAME
688 #undef PREPARE_LOOP
689 #undef END_LOOP
690 #undef EXTRA_LOOP_ARGS
691 #undef STORE_REST
692 #undef FROM_ONEBYTE