1 /* Skeleton for a conversion module.
2 Copyright (C) 1998-2014 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 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.
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 Lesser General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; if not, see
18 <http://www.gnu.org/licenses/>. */
19
20 /* This file can be included to provide definitions of several things
21 many modules have in common. It can be customized using the following
22 macros:
23
24 DEFINE_INIT define the default initializer. This requires the
25 following symbol to be defined.
26
27 CHARSET_NAME string with official name of the coded character
28 set (in all-caps)
29
30 DEFINE_FINI define the default destructor function.
31
32 MIN_NEEDED_FROM minimal number of bytes needed for the from-charset.
33 MIN_NEEDED_TO likewise for the to-charset.
34
35 MAX_NEEDED_FROM maximal number of bytes needed for the from-charset.
36 This macro is optional, it defaults to MIN_NEEDED_FROM.
37 MAX_NEEDED_TO likewise for the to-charset.
38
39 FROM_LOOP_MIN_NEEDED_FROM
40 FROM_LOOP_MAX_NEEDED_FROM
41 minimal/maximal number of bytes needed on input
42 of one round through the FROM_LOOP. Defaults
43 to MIN_NEEDED_FROM and MAX_NEEDED_FROM, respectively.
44 FROM_LOOP_MIN_NEEDED_TO
45 FROM_LOOP_MAX_NEEDED_TO
46 minimal/maximal number of bytes needed on output
47 of one round through the FROM_LOOP. Defaults
48 to MIN_NEEDED_TO and MAX_NEEDED_TO, respectively.
49 TO_LOOP_MIN_NEEDED_FROM
50 TO_LOOP_MAX_NEEDED_FROM
51 minimal/maximal number of bytes needed on input
52 of one round through the TO_LOOP. Defaults
53 to MIN_NEEDED_TO and MAX_NEEDED_TO, respectively.
54 TO_LOOP_MIN_NEEDED_TO
55 TO_LOOP_MAX_NEEDED_TO
56 minimal/maximal number of bytes needed on output
57 of one round through the TO_LOOP. Defaults
58 to MIN_NEEDED_FROM and MAX_NEEDED_FROM, respectively.
59
60 FROM_DIRECTION this macro is supposed to return a value != 0
61 if we convert from the current character set,
62 otherwise it return 0.
63
64 EMIT_SHIFT_TO_INIT this symbol is optional. If it is defined it
65 defines some code which writes out a sequence
66 of bytes which bring the current state into
67 the initial state.
68
69 FROM_LOOP name of the function implementing the conversion
70 from the current character set.
71 TO_LOOP likewise for the other direction
72
73 ONE_DIRECTION optional. If defined to 1, only one conversion
74 direction is defined instead of two. In this
75 case, FROM_DIRECTION should be defined to 1, and
76 FROM_LOOP and TO_LOOP should have the same value.
77
78 SAVE_RESET_STATE in case of an error we must reset the state for
79 the rerun so this macro must be defined for
80 stateful encodings. It takes an argument which
81 is nonzero when saving.
82
83 RESET_INPUT_BUFFER If the input character sets allow this the macro
84 can be defined to reset the input buffer pointers
85 to cover only those characters up to the error.
86
87 FUNCTION_NAME if not set the conversion function is named `gconv'.
88
89 PREPARE_LOOP optional code preparing the conversion loop. Can
90 contain variable definitions.
91 END_LOOP also optional, may be used to store information
92
93 EXTRA_LOOP_ARGS optional macro specifying extra arguments passed
94 to loop function.
95
96 STORE_REST optional, needed only when MAX_NEEDED_FROM > 4.
97 This macro stores the seen but unconverted input bytes
98 in the state.
99
100 FROM_ONEBYTE optional. If defined, should be the name of a
101 specialized conversion function for a single byte
102 from the current character set to INTERNAL. This
103 function has prototype
104 wint_t
105 FROM_ONEBYTE (struct __gconv_step *, unsigned char);
106 and does a special conversion:
107 - The input is a single byte.
108 - The output is a single uint32_t.
109 - The state before the conversion is the initial state;
110 the state after the conversion is irrelevant.
111 - No transliteration.
112 - __invocation_counter = 0.
113 - __internal_use = 1.
114 - do_flush = 0.
115
116 Modules can use mbstate_t to store conversion state as follows:
117
118 * Bits 2..0 of '__count' contain the number of lookahead input bytes
119 stored in __value.__wchb. Always zero if the converter never
120 returns __GCONV_INCOMPLETE_INPUT.
121
122 * Bits 31..3 of '__count' are module dependent shift state.
123
124 * __value: When STORE_REST/UNPACK_BYTES aren't defined and when the
125 converter has returned __GCONV_INCOMPLETE_INPUT, this contains
126 at most 4 lookahead bytes. Converters with an mb_cur_max > 4
127 (currently only UTF-8) must find a way to store their state
128 in __value.__wch and define STORE_REST/UNPACK_BYTES appropriately.
129
130 When __value contains lookahead, __count must not be zero, because
131 the converter is not in the initial state then, and mbsinit() --
132 defined as a (__count == 0) test -- must reflect this.
133 */
134
135 #include <assert.h>
136 #include <gconv.h>
137 #include <string.h>
138 #define __need_size_t
139 #define __need_NULL
140 #include <stddef.h>
141
142 #ifndef STATIC_GCONV
143 # include <dlfcn.h>
144 #endif
145
146 /* #include <sysdep.h> */
147 #include <stdint.h>
148
149 #ifndef DL_CALL_FCT
150 # define DL_CALL_FCT(fct, args) fct args
151 #endif
152
153 /* The direction objects. */
154 #if DEFINE_INIT
155 # ifndef FROM_DIRECTION
156 # define FROM_DIRECTION_VAL NULL
157 # define TO_DIRECTION_VAL ((void *) ~((uintptr_t) 0))
158 # define FROM_DIRECTION (step->__data == FROM_DIRECTION_VAL)
159 # endif
160 #else
161 # ifndef FROM_DIRECTION
162 # error "FROM_DIRECTION must be provided if non-default init is used"
163 # endif
164 #endif
165
166 /* How many bytes are needed at most for the from-charset. */
167 #ifndef MAX_NEEDED_FROM
168 # define MAX_NEEDED_FROM MIN_NEEDED_FROM
169 #endif
170
171 /* Same for the to-charset. */
172 #ifndef MAX_NEEDED_TO
173 # define MAX_NEEDED_TO MIN_NEEDED_TO
174 #endif
175
176 /* Defaults for the per-direction min/max constants. */
177 #ifndef FROM_LOOP_MIN_NEEDED_FROM
178 # define FROM_LOOP_MIN_NEEDED_FROM MIN_NEEDED_FROM
179 #endif
180 #ifndef FROM_LOOP_MAX_NEEDED_FROM
181 # define FROM_LOOP_MAX_NEEDED_FROM MAX_NEEDED_FROM
182 #endif
183 #ifndef FROM_LOOP_MIN_NEEDED_TO
184 # define FROM_LOOP_MIN_NEEDED_TO MIN_NEEDED_TO
185 #endif
186 #ifndef FROM_LOOP_MAX_NEEDED_TO
187 # define FROM_LOOP_MAX_NEEDED_TO MAX_NEEDED_TO
188 #endif
189 #ifndef TO_LOOP_MIN_NEEDED_FROM
190 # define TO_LOOP_MIN_NEEDED_FROM MIN_NEEDED_TO
191 #endif
192 #ifndef TO_LOOP_MAX_NEEDED_FROM
193 # define TO_LOOP_MAX_NEEDED_FROM MAX_NEEDED_TO
194 #endif
195 #ifndef TO_LOOP_MIN_NEEDED_TO
196 # define TO_LOOP_MIN_NEEDED_TO MIN_NEEDED_FROM
197 #endif
198 #ifndef TO_LOOP_MAX_NEEDED_TO
199 # define TO_LOOP_MAX_NEEDED_TO MAX_NEEDED_FROM
200 #endif
201
202
203 /* Define macros which can access unaligned buffers. These macros are
204 supposed to be used only in code outside the inner loops. For the inner
205 loops we have other definitions which allow optimized access. */
206 #if _STRING_ARCH_unaligned
207 /* We can handle unaligned memory access. */
208 # define get16u(addr) *((const uint16_t *) (addr))
209 # define get32u(addr) *((const uint32_t *) (addr))
210
211 /* We need no special support for writing values either. */
212 # define put16u(addr, val) *((uint16_t *) (addr)) = (val)
213 # define put32u(addr, val) *((uint32_t *) (addr)) = (val)
214 #else
215 /* Distinguish between big endian and little endian. */
216 # if __BYTE_ORDER == __LITTLE_ENDIAN
217 # define get16u(addr) \
218 (((const unsigned char *) (addr))[1] << 8 \
219 | ((const unsigned char *) (addr))[0])
220 # define get32u(addr) \
221 (((((const unsigned char *) (addr))[3] << 8 \
222 | ((const unsigned char *) (addr))[2]) << 8 \
223 | ((const unsigned char *) (addr))[1]) << 8 \
224 | ((const unsigned char *) (addr))[0])
225
226 # define put16u(addr, val) \
227 ({ uint16_t __val = (val); \
228 ((unsigned char *) (addr))[0] = __val; \
229 ((unsigned char *) (addr))[1] = __val >> 8; \
230 (void) 0; })
231 # define put32u(addr, val) \
232 ({ uint32_t __val = (val); \
233 ((unsigned char *) (addr))[0] = __val; \
234 __val >>= 8; \
235 ((unsigned char *) (addr))[1] = __val; \
236 __val >>= 8; \
237 ((unsigned char *) (addr))[2] = __val; \
238 __val >>= 8; \
239 ((unsigned char *) (addr))[3] = __val; \
240 (void) 0; })
241 # else
242 # define get16u(addr) \
243 (((const unsigned char *) (addr))[0] << 8 \
244 | ((const unsigned char *) (addr))[1])
245 # define get32u(addr) \
246 (((((const unsigned char *) (addr))[0] << 8 \
247 | ((const unsigned char *) (addr))[1]) << 8 \
248 | ((const unsigned char *) (addr))[2]) << 8 \
249 | ((const unsigned char *) (addr))[3])
250
251 # define put16u(addr, val) \
252 ({ uint16_t __val = (val); \
253 ((unsigned char *) (addr))[1] = __val; \
254 ((unsigned char *) (addr))[0] = __val >> 8; \
255 (void) 0; })
256 # define put32u(addr, val) \
257 ({ uint32_t __val = (val); \
258 ((unsigned char *) (addr))[3] = __val; \
259 __val >>= 8; \
260 ((unsigned char *) (addr))[2] = __val; \
261 __val >>= 8; \
262 ((unsigned char *) (addr))[1] = __val; \
263 __val >>= 8; \
264 ((unsigned char *) (addr))[0] = __val; \
265 (void) 0; })
266 # endif
267 #endif
268
269
270 /* For conversions from a fixed width character set to another fixed width
271 character set we can define RESET_INPUT_BUFFER in a very fast way. */
272 #if !defined RESET_INPUT_BUFFER && !defined SAVE_RESET_STATE
273 # if FROM_LOOP_MIN_NEEDED_FROM == FROM_LOOP_MAX_NEEDED_FROM \
274 && FROM_LOOP_MIN_NEEDED_TO == FROM_LOOP_MAX_NEEDED_TO \
275 && TO_LOOP_MIN_NEEDED_FROM == TO_LOOP_MAX_NEEDED_FROM \
276 && TO_LOOP_MIN_NEEDED_TO == TO_LOOP_MAX_NEEDED_TO
277 /* We have to use these `if's here since the compiler cannot know that
278 (outbuf - outerr) is always divisible by FROM/TO_LOOP_MIN_NEEDED_TO.
279 The ?:1 avoids division by zero warnings that gcc 3.2 emits even for
280 obviously unreachable code. */
281 # define RESET_INPUT_BUFFER \
282 if (FROM_DIRECTION) \
283 { \
284 if (FROM_LOOP_MIN_NEEDED_FROM % FROM_LOOP_MIN_NEEDED_TO == 0) \
285 *inptrp -= (outbuf - outerr) \
286 * (FROM_LOOP_MIN_NEEDED_FROM / FROM_LOOP_MIN_NEEDED_TO); \
287 else if (FROM_LOOP_MIN_NEEDED_TO % FROM_LOOP_MIN_NEEDED_FROM == 0) \
288 *inptrp -= (outbuf - outerr) \
289 / (FROM_LOOP_MIN_NEEDED_TO / FROM_LOOP_MIN_NEEDED_FROM \
290 ? : 1); \
291 else \
292 *inptrp -= ((outbuf - outerr) / FROM_LOOP_MIN_NEEDED_TO) \
293 * FROM_LOOP_MIN_NEEDED_FROM; \
294 } \
295 else \
296 { \
297 if (TO_LOOP_MIN_NEEDED_FROM % TO_LOOP_MIN_NEEDED_TO == 0) \
298 *inptrp -= (outbuf - outerr) \
299 * (TO_LOOP_MIN_NEEDED_FROM / TO_LOOP_MIN_NEEDED_TO); \
300 else if (TO_LOOP_MIN_NEEDED_TO % TO_LOOP_MIN_NEEDED_FROM == 0) \
301 *inptrp -= (outbuf - outerr) \
302 / (TO_LOOP_MIN_NEEDED_TO / TO_LOOP_MIN_NEEDED_FROM ? : 1); \
303 else \
304 *inptrp -= ((outbuf - outerr) / TO_LOOP_MIN_NEEDED_TO) \
305 * TO_LOOP_MIN_NEEDED_FROM; \
306 }
307 # endif
308 #endif
309
310
311 /* The default init function. It simply matches the name and initializes
312 the step data to point to one of the objects above. */
313 #if DEFINE_INIT
314 # ifndef CHARSET_NAME
315 # error "CHARSET_NAME not defined"
316 # endif
317
318 extern int gconv_init (struct __gconv_step *step);
319 int
gconv_init(struct __gconv_step * step)320 gconv_init (struct __gconv_step *step)
321 {
322 /* Determine which direction. */
323 if (strcmp (step->__from_name, CHARSET_NAME) == 0)
324 {
325 step->__data = FROM_DIRECTION_VAL;
326
327 step->__min_needed_from = FROM_LOOP_MIN_NEEDED_FROM;
328 step->__max_needed_from = FROM_LOOP_MAX_NEEDED_FROM;
329 step->__min_needed_to = FROM_LOOP_MIN_NEEDED_TO;
330 step->__max_needed_to = FROM_LOOP_MAX_NEEDED_TO;
331
332 #ifdef FROM_ONEBYTE
333 step->__btowc_fct = FROM_ONEBYTE;
334 #endif
335 }
336 else if (__builtin_expect (strcmp (step->__to_name, CHARSET_NAME), 0) == 0)
337 {
338 step->__data = TO_DIRECTION_VAL;
339
340 step->__min_needed_from = TO_LOOP_MIN_NEEDED_FROM;
341 step->__max_needed_from = TO_LOOP_MAX_NEEDED_FROM;
342 step->__min_needed_to = TO_LOOP_MIN_NEEDED_TO;
343 step->__max_needed_to = TO_LOOP_MAX_NEEDED_TO;
344 }
345 else
346 return __GCONV_NOCONV;
347
348 #ifdef SAVE_RESET_STATE
349 step->__stateful = 1;
350 #else
351 step->__stateful = 0;
352 #endif
353
354 return __GCONV_OK;
355 }
356 #endif
357
358
359 /* The default destructor function does nothing in the moment and so
360 we don't define it at all. But we still provide the macro just in
361 case we need it some day. */
362 #if DEFINE_FINI
363 #endif
364
365
366 /* If no arguments have to passed to the loop function define the macro
367 as empty. */
368 #ifndef EXTRA_LOOP_ARGS
369 # define EXTRA_LOOP_ARGS
370 #endif
371
372
373 /* This is the actual conversion function. */
374 #ifndef FUNCTION_NAME
375 # define FUNCTION_NAME gconv
376 #endif
377
378 /* The macros are used to access the function to convert single characters. */
379 #define SINGLE(fct) SINGLE2 (fct)
380 #define SINGLE2(fct) fct##_single
381
382
383 extern int FUNCTION_NAME (struct __gconv_step *step,
384 struct __gconv_step_data *data,
385 const unsigned char **inptrp,
386 const unsigned char *inend,
387 unsigned char **outbufstart, size_t *irreversible,
388 int do_flush, int consume_incomplete);
389 int
FUNCTION_NAME(struct __gconv_step * step,struct __gconv_step_data * data,const unsigned char ** inptrp,const unsigned char * inend,unsigned char ** outbufstart,size_t * irreversible,int do_flush,int consume_incomplete)390 FUNCTION_NAME (struct __gconv_step *step, struct __gconv_step_data *data,
391 const unsigned char **inptrp, const unsigned char *inend,
392 unsigned char **outbufstart, size_t *irreversible, int do_flush,
393 int consume_incomplete)
394 {
395 struct __gconv_step *next_step = step + 1;
396 struct __gconv_step_data *next_data = data + 1;
397 __gconv_fct fct = NULL;
398 int status;
399
400 if ((data->__flags & __GCONV_IS_LAST) == 0)
401 {
402 fct = next_step->__fct;
403 #ifdef PTR_DEMANGLE
404 if (next_step->__shlib_handle != NULL)
405 PTR_DEMANGLE (fct);
406 #endif
407 }
408
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
411 dropped. */
412 if (__glibc_unlikely (do_flush))
413 {
414 /* This should never happen during error handling. */
415 assert (outbufstart == NULL);
416
417 status = __GCONV_OK;
418
419 #ifdef EMIT_SHIFT_TO_INIT
420 if (do_flush == 1)
421 {
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;
426
427 # ifdef PREPARE_LOOP
428 PREPARE_LOOP
429 # endif
430
431 # ifdef SAVE_RESET_STATE
432 SAVE_RESET_STATE (1);
433 # endif
434
435 /* Emit the escape sequence to reset the state. */
436 EMIT_SHIFT_TO_INIT;
437
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
442 clean state. */
443 if (status == __GCONV_OK)
444 {
445 if (data->__flags & __GCONV_IS_LAST)
446 /* Store information about how many bytes are available. */
447 data->__outbuf = outbuf;
448 else
449 {
450 /* Write out all output which was produced. */
451 if (outbuf > outstart)
452 {
453 const unsigned char *outerr = outstart;
454 int result;
455
456 result = DL_CALL_FCT (fct, (next_step, next_data,
457 &outerr, outbuf, NULL,
458 irreversible, 0,
459 consume_incomplete));
460
461 if (result != __GCONV_EMPTY_INPUT)
462 {
463 if (__glibc_unlikely (outerr != outbuf))
464 {
465 /* We have a problem. Undo the conversion. */
466 outbuf = outstart;
467
468 /* Restore the state. */
469 # ifdef SAVE_RESET_STATE
470 SAVE_RESET_STATE (0);
471 # endif
472 }
473
474 /* Change the status. */
475 status = result;
476 }
477 }
478
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));
484 }
485 }
486 }
487 else
488 #endif
489 {
490 /* Clear the state object. There might be bytes in there from
491 previous calls with CONSUME_INCOMPLETE == 1. But don't emit
492 escape sequences. */
493 memset (data->__statep, '\0', sizeof (*data->__statep));
494
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));
500 }
501 }
502 else
503 {
504 #if ! __GLIBC_PREREQ(2,21)
505 /* We preserve the initial values of the pointer variables. */
506 const unsigned char *inptr = *inptrp;
507 #else
508 /* We preserve the initial values of the pointer variables,
509 but only some conversion modules need it. */
510 const unsigned char *inptr __attribute__ ((__unused__)) = *inptrp;
511 #endif
512 unsigned char *outbuf = (__builtin_expect (outbufstart == NULL, 1)
513 ? data->__outbuf : *outbufstart);
514 unsigned char *outend = data->__outbufend;
515 unsigned char *outstart;
516 /* This variable is used to count the number of characters we
517 actually converted. */
518 size_t lirreversible = 0;
519 size_t *lirreversiblep = irreversible ? &lirreversible : NULL;
520
521 /* The following assumes that encodings, which have a variable length
522 what might unalign a buffer even though it is an aligned in the
523 beginning, either don't have the minimal number of bytes as a divisor
524 of the maximum length or have a minimum length of 1. This is true
525 for all known and supported encodings.
526 We use && instead of || to combine the subexpression for the FROM
527 encoding and for the TO encoding, because usually one of them is
528 INTERNAL, for which the subexpression evaluates to 1, but INTERNAL
529 buffers are always aligned correctly. */
530 #define POSSIBLY_UNALIGNED \
531 (!_STRING_ARCH_unaligned \
532 && (((FROM_LOOP_MIN_NEEDED_FROM != 1 \
533 && FROM_LOOP_MAX_NEEDED_FROM % FROM_LOOP_MIN_NEEDED_FROM == 0) \
534 && (FROM_LOOP_MIN_NEEDED_TO != 1 \
535 && FROM_LOOP_MAX_NEEDED_TO % FROM_LOOP_MIN_NEEDED_TO == 0)) \
536 || ((TO_LOOP_MIN_NEEDED_FROM != 1 \
537 && TO_LOOP_MAX_NEEDED_FROM % TO_LOOP_MIN_NEEDED_FROM == 0) \
538 && (TO_LOOP_MIN_NEEDED_TO != 1 \
539 && TO_LOOP_MAX_NEEDED_TO % TO_LOOP_MIN_NEEDED_TO == 0))))
540 #if POSSIBLY_UNALIGNED
541 int unaligned;
542 # define GEN_unaligned(name) GEN_unaligned2 (name)
543 # define GEN_unaligned2(name) name##_unaligned
544 #else
545 # define unaligned 0
546 #endif
547
548 #ifdef PREPARE_LOOP
549 PREPARE_LOOP
550 #endif
551
552 #if FROM_LOOP_MAX_NEEDED_FROM > 1 || TO_LOOP_MAX_NEEDED_FROM > 1
553 /* If the function is used to implement the mb*towc*() or wc*tomb*()
554 functions we must test whether any bytes from the last call are
555 stored in the `state' object. */
556 if (((FROM_LOOP_MAX_NEEDED_FROM > 1 && TO_LOOP_MAX_NEEDED_FROM > 1)
557 || (FROM_LOOP_MAX_NEEDED_FROM > 1 && FROM_DIRECTION)
558 || (TO_LOOP_MAX_NEEDED_FROM > 1 && !FROM_DIRECTION))
559 && consume_incomplete && (data->__statep->__count & 7) != 0)
560 {
561 /* Yep, we have some bytes left over. Process them now.
562 But this must not happen while we are called from an
563 error handler. */
564 assert (outbufstart == NULL);
565
566 # if FROM_LOOP_MAX_NEEDED_FROM > 1
567 if (TO_LOOP_MAX_NEEDED_FROM == 1 || FROM_DIRECTION)
568 status = SINGLE(FROM_LOOP) (step, data, inptrp, inend, &outbuf,
569 outend, lirreversiblep
570 EXTRA_LOOP_ARGS);
571 # endif
572 # if !ONE_DIRECTION
573 # if FROM_LOOP_MAX_NEEDED_FROM > 1 && TO_LOOP_MAX_NEEDED_FROM > 1
574 else
575 # endif
576 # if TO_LOOP_MAX_NEEDED_FROM > 1
577 status = SINGLE(TO_LOOP) (step, data, inptrp, inend, &outbuf,
578 outend, lirreversiblep EXTRA_LOOP_ARGS);
579 # endif
580 # endif
581
582 if (__builtin_expect (status, __GCONV_OK) != __GCONV_OK)
583 return status;
584 }
585 #endif
586
587 #if POSSIBLY_UNALIGNED
588 unaligned =
589 ((FROM_DIRECTION
590 && ((uintptr_t) inptr % FROM_LOOP_MIN_NEEDED_FROM != 0
591 || ((data->__flags & __GCONV_IS_LAST)
592 && (uintptr_t) outbuf % FROM_LOOP_MIN_NEEDED_TO != 0)))
593 || (!FROM_DIRECTION
594 && (((data->__flags & __GCONV_IS_LAST)
595 && (uintptr_t) outbuf % TO_LOOP_MIN_NEEDED_TO != 0)
596 || (uintptr_t) inptr % TO_LOOP_MIN_NEEDED_FROM != 0)));
597 #endif
598
599 while (1)
600 {
601 #if ! __GLIBC_PREREQ(2,21)
602 struct __gconv_trans_data *trans;
603
604 #endif
605 /* Remember the start value for this round. */
606 inptr = *inptrp;
607 /* The outbuf buffer is empty. */
608 outstart = outbuf;
609
610 #ifdef SAVE_RESET_STATE
611 SAVE_RESET_STATE (1);
612 #endif
613
614 if (__glibc_likely (!unaligned))
615 {
616 if (FROM_DIRECTION)
617 /* Run the conversion loop. */
618 status = FROM_LOOP (step, data, inptrp, inend, &outbuf, outend,
619 lirreversiblep EXTRA_LOOP_ARGS);
620 else
621 /* Run the conversion loop. */
622 status = TO_LOOP (step, data, inptrp, inend, &outbuf, outend,
623 lirreversiblep EXTRA_LOOP_ARGS);
624 }
625 #if POSSIBLY_UNALIGNED
626 else
627 {
628 if (FROM_DIRECTION)
629 /* Run the conversion loop. */
630 status = GEN_unaligned (FROM_LOOP) (step, data, inptrp, inend,
631 &outbuf, outend,
632 lirreversiblep
633 EXTRA_LOOP_ARGS);
634 else
635 /* Run the conversion loop. */
636 status = GEN_unaligned (TO_LOOP) (step, data, inptrp, inend,
637 &outbuf, outend,
638 lirreversiblep
639 EXTRA_LOOP_ARGS);
640 }
641 #endif
642
643 /* If we were called as part of an error handling module we
644 don't do anything else here. */
645 if (__glibc_unlikely (outbufstart != NULL))
646 {
647 *outbufstart = outbuf;
648 return status;
649 }
650
651 #if ! __GLIBC_PREREQ(2,21)
652 /* Give the transliteration module the chance to store the
653 original text and the result in case it needs a context. */
654 for (trans = data->__trans; trans != NULL; trans = trans->__next)
655 if (trans->__trans_context_fct != NULL)
656 DL_CALL_FCT (trans->__trans_context_fct,
657 (trans->__data, inptr, *inptrp, outstart, outbuf));
658
659 #endif
660 /* We finished one use of the loops. */
661 ++data->__invocation_counter;
662
663 /* If this is the last step leave the loop, there is nothing
664 we can do. */
665 if (__glibc_unlikely (data->__flags & __GCONV_IS_LAST))
666 {
667 /* Store information about how many bytes are available. */
668 data->__outbuf = outbuf;
669
670 /* Remember how many non-identical characters we
671 converted in an irreversible way. */
672 *irreversible += lirreversible;
673
674 break;
675 }
676
677 /* Write out all output which was produced. */
678 if (__glibc_likely (outbuf > outstart))
679 {
680 const unsigned char *outerr = data->__outbuf;
681 int result;
682
683 result = DL_CALL_FCT (fct, (next_step, next_data, &outerr,
684 outbuf, NULL, irreversible, 0,
685 consume_incomplete));
686
687 if (result != __GCONV_EMPTY_INPUT)
688 {
689 if (__glibc_unlikely (outerr != outbuf))
690 {
691 #ifdef RESET_INPUT_BUFFER
692 RESET_INPUT_BUFFER;
693 #else
694 /* We have a problem in one of the functions below.
695 Undo the conversion upto the error point. */
696 size_t nstatus;
697
698 /* Reload the pointers. */
699 *inptrp = inptr;
700 outbuf = outstart;
701
702 /* Restore the state. */
703 # ifdef SAVE_RESET_STATE
704 SAVE_RESET_STATE (0);
705 # endif
706
707 if (__glibc_likely (!unaligned))
708 {
709 if (FROM_DIRECTION)
710 /* Run the conversion loop. */
711 nstatus = FROM_LOOP (step, data, inptrp, inend,
712 &outbuf, outerr,
713 lirreversiblep
714 EXTRA_LOOP_ARGS);
715 else
716 /* Run the conversion loop. */
717 nstatus = TO_LOOP (step, data, inptrp, inend,
718 &outbuf, outerr,
719 lirreversiblep
720 EXTRA_LOOP_ARGS);
721 }
722 # if POSSIBLY_UNALIGNED
723 else
724 {
725 if (FROM_DIRECTION)
726 /* Run the conversion loop. */
727 nstatus = GEN_unaligned (FROM_LOOP) (step, data,
728 inptrp, inend,
729 &outbuf,
730 outerr,
731 lirreversiblep
732 EXTRA_LOOP_ARGS);
733 else
734 /* Run the conversion loop. */
735 nstatus = GEN_unaligned (TO_LOOP) (step, data,
736 inptrp, inend,
737 &outbuf, outerr,
738 lirreversiblep
739 EXTRA_LOOP_ARGS);
740 }
741 # endif
742
743 /* We must run out of output buffer space in this
744 rerun. */
745 assert (outbuf == outerr);
746 assert (nstatus == __GCONV_FULL_OUTPUT);
747
748 /* If we haven't consumed a single byte decrement
749 the invocation counter. */
750 if (__glibc_unlikely (outbuf == outstart))
751 --data->__invocation_counter;
752 #endif /* reset input buffer */
753 }
754
755 /* Change the status. */
756 status = result;
757 }
758 else
759 /* All the output is consumed, we can make another run
760 if everything was ok. */
761 if (status == __GCONV_FULL_OUTPUT)
762 {
763 status = __GCONV_OK;
764 outbuf = data->__outbuf;
765 }
766 }
767
768 if (status != __GCONV_OK)
769 break;
770
771 /* Reset the output buffer pointer for the next round. */
772 outbuf = data->__outbuf;
773 }
774
775 #ifdef END_LOOP
776 END_LOOP
777 #endif
778
779 /* If we are supposed to consume all character store now all of the
780 remaining characters in the `state' object. */
781 #if FROM_LOOP_MAX_NEEDED_FROM > 1 || TO_LOOP_MAX_NEEDED_FROM > 1
782 if (((FROM_LOOP_MAX_NEEDED_FROM > 1 && TO_LOOP_MAX_NEEDED_FROM > 1)
783 || (FROM_LOOP_MAX_NEEDED_FROM > 1 && FROM_DIRECTION)
784 || (TO_LOOP_MAX_NEEDED_FROM > 1 && !FROM_DIRECTION))
785 && __builtin_expect (consume_incomplete, 0)
786 && status == __GCONV_INCOMPLETE_INPUT)
787 {
788 # ifdef STORE_REST
789 mbstate_t *state = data->__statep;
790
791 STORE_REST
792 # else
793 /* Make sure the remaining bytes fit into the state objects
794 buffer. */
795 assert (inend - *inptrp < 4);
796
797 size_t cnt;
798 for (cnt = 0; *inptrp < inend; ++cnt)
799 data->__statep->__value.__wchb[cnt] = *(*inptrp)++;
800 data->__statep->__count &= ~7;
801 data->__statep->__count |= cnt;
802 # endif
803 }
804 #endif
805 #undef unaligned
806 #undef POSSIBLY_UNALIGNED
807 }
808
809 return status;
810 }
811
812 #undef DEFINE_INIT
813 #undef CHARSET_NAME
814 #undef DEFINE_FINI
815 #undef MIN_NEEDED_FROM
816 #undef MIN_NEEDED_TO
817 #undef MAX_NEEDED_FROM
818 #undef MAX_NEEDED_TO
819 #undef FROM_LOOP_MIN_NEEDED_FROM
820 #undef FROM_LOOP_MAX_NEEDED_FROM
821 #undef FROM_LOOP_MIN_NEEDED_TO
822 #undef FROM_LOOP_MAX_NEEDED_TO
823 #undef TO_LOOP_MIN_NEEDED_FROM
824 #undef TO_LOOP_MAX_NEEDED_FROM
825 #undef TO_LOOP_MIN_NEEDED_TO
826 #undef TO_LOOP_MAX_NEEDED_TO
827 #undef FROM_DIRECTION
828 #undef EMIT_SHIFT_TO_INIT
829 #undef FROM_LOOP
830 #undef TO_LOOP
831 #undef ONE_DIRECTION
832 #undef SAVE_RESET_STATE
833 #undef RESET_INPUT_BUFFER
834 #undef FUNCTION_NAME
835 #undef PREPARE_LOOP
836 #undef END_LOOP
837 #undef EXTRA_LOOP_ARGS
838 #undef STORE_REST
839 #undef FROM_ONEBYTE
840