(__gconv_read_conf): Don't call realpath.
[kopensolaris-gnu/glibc.git] / iconv / skeleton.c
1 /* Skeleton for a conversion module.
2    Copyright (C) 1998, 1999, 2000 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 can be included to provide definitions of several things
22    many modules have in common.  It can be customized using the following
23    macros:
24
25      DEFINE_INIT        define the default initializer.  This requires the
26                         following symbol to be defined.
27
28      CHARSET_NAME       string with official name of the coded character
29                         set (in all-caps)
30
31      DEFINE_FINI        define the default destructor function.
32
33      MIN_NEEDED_FROM    minimal number of bytes needed for the from-charset.
34      MIN_NEEDED_TO      likewise for the to-charset.
35
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.
39
40      DEFINE_DIRECTION_OBJECTS
41                         two objects will be defined to be used when the
42                         `gconv' function must only distinguish two
43                         directions.  This is implied by DEFINE_INIT.
44                         If this macro is not defined the following
45                         macro must be available.
46
47      FROM_DIRECTION     this macro is supposed to return a value != 0
48                         if we convert from the current character set,
49                         otherwise it return 0.
50
51      EMIT_SHIFT_TO_INIT this symbol is optional.  If it is defined it
52                         defines some code which writes out a sequence
53                         of characters which bring the current state into
54                         the initial state.
55
56      FROM_LOOP          name of the function implementing the conversion
57                         from the current characters.
58      TO_LOOP            likewise for the other direction
59
60      RESET_STATE        in case of an error we must reset the state for
61                         the rerun so this macro must be defined for
62                         stateful encodings.  It takes an argument which
63                         is nonzero when saving.
64
65      RESET_INPUT_BUFFER If the input character sets allow this the macro
66                         can be defined to reset the input buffer pointers
67                         to cover only those characters up to the error.
68
69      FUNCTION_NAME      if not set the conversion function is named `gconv'.
70
71      PREPARE_LOOP       optional code preparing the conversion loop.  Can
72                         contain variable definitions.
73      END_LOOP           also optional, may be used to store information
74
75      EXTRA_LOOP_ARGS    optional macro specifying extra arguments passed
76                         to loop function.
77  */
78
79 #include <assert.h>
80 #include <gconv.h>
81 #include <string.h>
82 #define __need_size_t
83 #define __need_NULL
84 #include <stddef.h>
85
86 #ifndef STATIC_GCONV
87 # include <dlfcn.h>
88 #endif
89
90 #ifndef DL_CALL_FCT
91 # define DL_CALL_FCT(fct, args) fct args
92 #endif
93
94 /* The direction objects.  */
95 #if DEFINE_DIRECTION_OBJECTS || DEFINE_INIT
96 static int from_object;
97 static int to_object;
98
99 # ifndef FROM_DIRECTION
100 #  define FROM_DIRECTION (step->__data == &from_object)
101 # endif
102 #else
103 # ifndef FROM_DIRECTION
104 #  error "FROM_DIRECTION must be provided if direction objects are not used"
105 # endif
106 #endif
107
108
109 /* How many bytes are needed at most for the from-charset.  */
110 #ifndef MAX_NEEDED_FROM
111 # define MAX_NEEDED_FROM        MIN_NEEDED_FROM
112 #endif
113
114 /* Same for the to-charset.  */
115 #ifndef MAX_NEEDED_TO
116 # define MAX_NEEDED_TO          MIN_NEEDED_TO
117 #endif
118
119
120 /* Define macros which can access unaligned buffers.  These macros are
121    supposed to be used only in code outside the inner loops.  For the inner
122    loops we have other definitions which allow optimized access.  */
123 #ifdef _STRING_ARCH_unaligned
124 /* We can handle unaligned memory access.  */
125 # define get16u(addr) *((uint16_t *) (addr))
126 # define get32u(addr) *((uint32_t *) (addr))
127
128 /* We need no special support for writing values either.  */
129 # define put16u(addr, val) *((uint16_t *) (addr)) = (val)
130 # define put32u(addr, val) *((uint32_t *) (addr)) = (val)
131 #else
132 /* Distinguish between big endian and little endian.  */
133 # if __BYTE_ORDER == __LITTLE_ENDIAN
134 #  define get16u(addr) \
135      (((__const unsigned char *) (addr))[1] << 8                              \
136       | ((__const unsigned char *) (addr))[0])
137 #  define get32u(addr) \
138      (((((__const unsigned char *) (addr))[3] << 8                            \
139         | ((__const unsigned char *) (addr))[2]) << 8                         \
140        | ((__const unsigned char *) (addr))[1]) << 8                          \
141       | ((__const unsigned char *) (addr))[0])
142
143 #  define put16u(addr, val) \
144      ({ uint16_t __val = (val);                                               \
145         ((unsigned char *) (addr))[0] = __val;                                \
146         ((unsigned char *) (addr))[1] = __val >> 8;                           \
147         (void) 0; })
148 #  define put32u(addr, val) \
149      ({ uint32_t __val = (val);                                               \
150         ((unsigned char *) (addr))[0] = __val;                                \
151         __val >>= 8;                                                          \
152         ((unsigned char *) (addr))[1] = __val;                                \
153         __val >>= 8;                                                          \
154         ((unsigned char *) (addr))[2] = __val;                                \
155         __val >>= 8;                                                          \
156         ((unsigned char *) (addr))[3] = __val;                                \
157         (void) 0; })
158 # else
159 #  define get16u(addr) \
160      (((__const unsigned char *) (addr))[0] << 8                              \
161       | ((__const unsigned char *) (addr))[1])
162 #  define get32u(addr) \
163      (((((__const unsigned char *) (addr))[0] << 8                            \
164         | ((__const unsigned char *) (addr))[1]) << 8                         \
165        | ((__const unsigned char *) (addr))[2]) << 8                          \
166       | ((__const unsigned char *) (addr))[3])
167
168 #  define put16u(addr, val) \
169      ({ uint16_t __val = (val);                                               \
170         ((unsigned char *) (addr))[1] = __val;                                \
171         ((unsigned char *) (addr))[0] = __val >> 8;                           \
172         (void) 0; })
173 #  define put32u(addr, val) \
174      ({ uint32_t __val = (val);                                               \
175         ((unsigned char *) (addr))[3] = __val;                                \
176         __val >>= 8;                                                          \
177         ((unsigned char *) (addr))[2] = __val;                                \
178         __val >>= 8;                                                          \
179         ((unsigned char *) (addr))[1] = __val;                                \
180         __val >>= 8;                                                          \
181         ((unsigned char *) (addr))[0] = __val;                                \
182         (void) 0; })
183 # endif
184 #endif
185
186
187 /* For conversions from a fixed width character sets to another fixed width
188    character set we we can define RESET_INPUT_BUFFER is necessary.  */
189 #if !defined RESET_INPUT_BUFFER && !defined SAVE_RESET_STATE
190 # if MIN_NEEDED_FROM == MAX_NEEDED_FROM && MIN_NEEDED_TO == MAX_NEEDED_TO
191 /* We have to use these `if's here since the compiler cannot know that
192    (outbuf - outerr) is always divisible by MIN_NEEDED_TO.  */
193 #  define RESET_INPUT_BUFFER \
194   if (MIN_NEEDED_FROM % MIN_NEEDED_TO == 0)                                   \
195     *inptrp -= (outbuf - outerr) * (MIN_NEEDED_FROM / MIN_NEEDED_TO);         \
196   else if (MIN_NEEDED_TO % MIN_NEEDED_FROM == 0)                              \
197     *inptrp -= (outbuf - outerr) / (MIN_NEEDED_TO / MIN_NEEDED_FROM);         \
198   else                                                                        \
199     *inptrp -= ((outbuf - outerr) / MIN_NEEDED_TO) * MIN_NEEDED_FROM
200 # endif
201 #endif
202
203
204 /* The default init function.  It simply matches the name and initializes
205    the step data to point to one of the objects above.  */
206 #if DEFINE_INIT
207 # ifndef CHARSET_NAME
208 #  error "CHARSET_NAME not defined"
209 # endif
210
211 int
212 gconv_init (struct __gconv_step *step)
213 {
214   /* Determine which direction.  */
215   if (strcmp (step->__from_name, CHARSET_NAME) == 0)
216     {
217       step->__data = &from_object;
218
219       step->__min_needed_from = MIN_NEEDED_FROM;
220       step->__max_needed_from = MAX_NEEDED_FROM;
221       step->__min_needed_to = MIN_NEEDED_TO;
222       step->__max_needed_to = MAX_NEEDED_TO;
223     }
224   else if (__builtin_expect (strcmp (step->__to_name, CHARSET_NAME), 0) == 0)
225     {
226       step->__data = &to_object;
227
228       step->__min_needed_from = MIN_NEEDED_TO;
229       step->__max_needed_from = MAX_NEEDED_TO;
230       step->__min_needed_to = MIN_NEEDED_FROM;
231       step->__max_needed_to = MAX_NEEDED_FROM;
232     }
233   else
234     return __GCONV_NOCONV;
235
236 #ifdef RESET_STATE
237   step->__stateful = 1;
238 #else
239   step->__stateful = 0;
240 #endif
241
242   return __GCONV_OK;
243 }
244 #endif
245
246
247 /* The default destructor function does nothing in the moment and so
248    be define it at all.  But we still provide the macro just in case
249    we need it some day.  */
250 #if DEFINE_FINI
251 #endif
252
253
254 /* If no arguments have to passed to the loop function define the macro
255    as empty.  */
256 #ifndef EXTRA_LOOP_ARGS
257 # define EXTRA_LOOP_ARGS
258 #endif
259
260
261 /* This is the actual conversion function.  */
262 #ifndef FUNCTION_NAME
263 # define FUNCTION_NAME  gconv
264 #endif
265
266 /* The macros are used to access the function to convert single characters.  */
267 #define SINGLE(fct) SINGLE2 (fct)
268 #define SINGLE2(fct) fct##_single
269
270
271 int
272 FUNCTION_NAME (struct __gconv_step *step, struct __gconv_step_data *data,
273                const unsigned char **inptrp, const unsigned char *inend,
274                unsigned char **outbufstart, size_t *irreversible, int do_flush,
275                int consume_incomplete)
276 {
277   struct __gconv_step *next_step = step + 1;
278   struct __gconv_step_data *next_data = data + 1;
279   __gconv_fct fct;
280   int status;
281
282   fct = (data->__flags & __GCONV_IS_LAST) ? NULL : next_step->__fct;
283
284   /* If the function is called with no input this means we have to reset
285      to the initial state.  The possibly partly converted input is
286      dropped.  */
287   if (__builtin_expect (do_flush, 0))
288     {
289       status = __GCONV_OK;
290
291       /* This should never happen during error handling.  */
292       assert (outbufstart == NULL);
293
294 #ifdef EMIT_SHIFT_TO_INIT
295       /* Emit the escape sequence to reset the state.  */
296       EMIT_SHIFT_TO_INIT;
297 #else
298       /* Clear the state object.  There might be bytes in there from
299          previous calls with CONSUME_INCOMPLETE == 1.  */
300       memset (data->__statep, '\0', sizeof (*data->__statep));
301 #endif
302       /* Call the steps down the chain if there are any but only if we
303          successfully emitted the escape sequence.  This should only
304          fail if the output buffer is full.  If the input is invalid
305          it should be discarded since the user wants to start from a
306          clean slate.  */
307       if (status == __GCONV_OK && ! (data->__flags & __GCONV_IS_LAST))
308         status = DL_CALL_FCT (fct, (next_step, next_data, NULL, NULL,
309                                     NULL, irreversible, 1,
310                                     consume_incomplete));
311     }
312   else
313     {
314       /* We preserve the initial values of the pointer variables.  */
315       const unsigned char *inptr = *inptrp;
316       unsigned char *outbuf = (__builtin_expect (outbufstart == NULL, 1)
317                                ? data->__outbuf : *outbufstart);
318       unsigned char *outend = data->__outbufend;
319       unsigned char *outstart;
320       /* This variable is used to count the number of characters we
321          actually converted.  */
322       size_t lirreversible = 0;
323 #if defined _STRING_ARCH_unaligned \
324     || MIN_NEEDED_FROM == 1 || MAX_NEEDED_FROM % MIN_NEEDED_FROM != 0 \
325     || MIN_NEEDED_TO == 1 || MAX_NEEDED_TO % MIN_NEEDED_TO != 0
326 # define unaligned 0
327 #else
328       int unaligned;
329 # define GEN_unaligned(name) GEN_unaligned2 (name)
330 # define GEN_unaligned2(name) name##_unaligned
331 #endif
332
333 #ifdef PREPARE_LOOP
334       PREPARE_LOOP
335 #endif
336
337 #if MAX_NEEDED_FROM > 1 || MAX_NEEDED_TO > 1
338       /* If the function is used to implement the mb*towc*() or wc*tomb*()
339          functions we must test whether any bytes from the last call are
340          stored in the `state' object.  */
341       if (((MAX_NEEDED_FROM > 1 && FROM_DIRECTION)
342            || (MAX_NEEDED_TO > 1 && !FROM_DIRECTION))
343           && consume_incomplete && (data->__statep->__count & 7) != 0)
344         {
345           /* Yep, we have some bytes left over.  Process them now.
346              But this must not happen while we are called from an
347              error handler.  */
348           assert (outbufstart == NULL);
349
350 # if MAX_NEEDED_FROM > 1
351           if (MAX_NEEDED_TO == 1 || FROM_DIRECTION)
352             status = SINGLE(FROM_LOOP) (step, data, inptrp, inend, &outbuf,
353                                         outend, &lirreversible
354                                         EXTRA_LOOP_ARGS);
355 # endif
356 # if MAX_NEEDED_FROM > 1 && MAX_NEEDED_TO > 1 && !ONE_DIRECTION
357           else
358 # endif
359 # if MAX_NEEDED_TO > 1 && !ONE_DIRECTION
360             status = SINGLE(TO_LOOP) (step, data, inptrp, inend, &outbuf,
361                                       outend, &lirreversible EXTRA_LOOP_ARGS);
362 # endif
363
364           if (__builtin_expect (status, __GCONV_OK) != __GCONV_OK)
365             return status;
366         }
367 #endif
368
369 #if !defined _STRING_ARCH_unaligned \
370     && MIN_NEEDED_FROM != 1 && MAX_NEEDED_FROM % MIN_NEEDED_FROM == 0 \
371     && MIN_NEEDED_TO != 1 && MAX_NEEDED_TO % MIN_NEEDED_TO == 0
372       /* The following assumes that encodings, which have a variable length
373          what might unalign a buffer even though it is a aligned in the
374          beginning, either don't have the minimal number of bytes as a divisor
375          of the maximum length or have a minimum length of 1.  This is true
376          for all known and supported encodings.  */
377       unaligned = ((FROM_DIRECTION
378                     && ((uintptr_t) inptr % MIN_NEEDED_FROM != 0
379                         || ((data->__flags & __GCONV_IS_LAST)
380                             && (uintptr_t) outbuf % MIN_NEEDED_TO != 0)))
381                    || (!FROM_DIRECTION
382                        && (((data->__flags & __GCONV_IS_LAST)
383                             && (uintptr_t) outbuf % MIN_NEEDED_FROM != 0)
384                            || (uintptr_t) inptr % MIN_NEEDED_TO != 0)));
385 #endif
386
387       do
388         {
389           struct __gconv_trans_data *trans;
390
391           /* Remember the start value for this round.  */
392           inptr = *inptrp;
393           /* The outbuf buffer is empty.  */
394           outstart = outbuf;
395
396 #ifdef SAVE_RESET_STATE
397           SAVE_RESET_STATE (1);
398 #endif
399
400           if (__builtin_expect (!unaligned, 1))
401             {
402               if (FROM_DIRECTION)
403                 /* Run the conversion loop.  */
404                 status = FROM_LOOP (step, data, inptrp, inend, &outbuf, outend,
405                                     &lirreversible EXTRA_LOOP_ARGS);
406               else
407                 /* Run the conversion loop.  */
408                 status = TO_LOOP (step, data, inptrp, inend, &outbuf, outend,
409                                   &lirreversible EXTRA_LOOP_ARGS);
410             }
411 #if !defined _STRING_ARCH_unaligned \
412     && MIN_NEEDED_FROM != 1 && MAX_NEEDED_FROM % MIN_NEEDED_FROM == 0 \
413     && MIN_NEEDED_TO != 1 && MAX_NEEDED_TO % MIN_NEEDED_TO == 0
414           else
415             {
416               if (FROM_DIRECTION)
417                 /* Run the conversion loop.  */
418                 status = GEN_unaligned (FROM_LOOP) (step, data, inptrp, inend,
419                                                     &outbuf, outend,
420                                                     &lirreversible
421                                                     EXTRA_LOOP_ARGS);
422               else
423                 /* Run the conversion loop.  */
424                 status = GEN_unaligned (TO_LOOP) (step, data, inptrp, inend,
425                                                   &outbuf, outend,
426                                                   &lirreversible
427                                                   EXTRA_LOOP_ARGS);
428             }
429 #endif
430
431           /* If we were called as part of an error handling module we
432              don't do anything else here.  */
433           if (__builtin_expect (outbufstart != NULL, 0))
434             {
435               *outbufstart = outbuf;
436               return status;
437             }
438
439           /* Give the transliteration module the chance to store the
440              original text and the result in case it needs a context.  */
441           for (trans = data->__trans; trans != NULL; trans = trans->__next)
442             if (trans->__trans_context_fct != NULL)
443               DL_CALL_FCT (trans->__trans_context_fct,
444                            (trans->__data, inptr, *inptrp, outstart, outbuf));
445
446           /* We finished one use of the loops.  */
447           ++data->__invocation_counter;
448
449           /* If this is the last step leave the loop, there is nothing
450              we can do.  */
451           if (__builtin_expect (data->__flags & __GCONV_IS_LAST, 0))
452             {
453               /* Store information about how many bytes are available.  */
454               data->__outbuf = outbuf;
455
456               /* Remember how many non-identical characters we
457                  converted in a irreversible way.  */
458               *irreversible += lirreversible;
459
460               break;
461             }
462
463           /* Write out all output which was produced.  */
464           if (__builtin_expect (outbuf > outstart, 1))
465             {
466               const unsigned char *outerr = data->__outbuf;
467               int result;
468
469               result = DL_CALL_FCT (fct, (next_step, next_data, &outerr,
470                                           outbuf, NULL, irreversible, 0,
471                                           consume_incomplete));
472
473               if (result != __GCONV_EMPTY_INPUT)
474                 {
475                   if (__builtin_expect (outerr != outbuf, 0))
476                     {
477 #ifdef RESET_INPUT_BUFFER
478                       RESET_INPUT_BUFFER;
479 #else
480                       /* We have a problem with the in on of the functions
481                          below.  Undo the conversion upto the error point.  */
482                       size_t nstatus;
483
484                       /* Reload the pointers.  */
485                       *inptrp = inptr;
486                       outbuf = outstart;
487
488                       /* Reset the state.  */
489 # ifdef SAVE_RESET_STATE
490                       SAVE_RESET_STATE (0);
491 # endif
492
493                       /* XXX Handle unaligned access here as well.  */
494                       if (FROM_DIRECTION)
495                         /* Run the conversion loop.  */
496                         nstatus = FROM_LOOP (step, data,
497                                              (const unsigned char **) inptrp,
498                                              (const unsigned char *) inend,
499                                              (unsigned char **) &outbuf,
500                                              (unsigned char *) outerr,
501                                              &lirreversible EXTRA_LOOP_ARGS);
502                       else
503                         /* Run the conversion loop.  */
504                         nstatus = TO_LOOP (step, data,
505                                            (const unsigned char **) inptrp,
506                                            (const unsigned char *) inend,
507                                            (unsigned char **) &outbuf,
508                                            (unsigned char *) outerr,
509                                            &lirreversible EXTRA_LOOP_ARGS);
510
511                       /* We must run out of output buffer space in this
512                          rerun.  */
513                       assert (outbuf == outerr);
514                       assert (nstatus == __GCONV_FULL_OUTPUT);
515
516                       /* If we haven't consumed a single byte decrement
517                          the invocation counter.  */
518                       if (__builtin_expect (outbuf == outstart, 0))
519                         --data->__invocation_counter;
520 #endif  /* reset input buffer */
521                     }
522
523                   /* Change the status.  */
524                   status = result;
525                 }
526               else
527                 /* All the output is consumed, we can make another run
528                    if everything was ok.  */
529                 if (status == __GCONV_FULL_OUTPUT)
530                   status = __GCONV_OK;
531             }
532         }
533       while (status == __GCONV_OK);
534
535 #ifdef END_LOOP
536       END_LOOP
537 #endif
538
539       /* If we are supposed to consume all character store now all of the
540          remaining characters in the `state' object.  */
541 #if MAX_NEEDED_FROM > 1 || MAX_NEEDED_TO > 1
542       if (((MAX_NEEDED_FROM > 1 && FROM_DIRECTION)
543            || (MAX_NEEDED_TO > 1 && !FROM_DIRECTION))
544           && __builtin_expect (consume_incomplete, 0)
545           && status == __GCONV_INCOMPLETE_INPUT)
546         {
547 # ifdef STORE_REST
548           mbstate_t *state = data->__statep;
549
550           STORE_REST
551 # else
552           size_t cnt;
553
554           /* Make sure the remaining bytes fit into the state objects
555              buffer.  */
556           assert (inend - *inptrp < 4);
557
558           for (cnt = 0; *inptrp < inend; ++cnt)
559             data->__statep->__value.__wchb[cnt] = *(*inptrp)++;
560           data->__statep->__count &= ~7;
561           data->__statep->__count |= cnt;
562 # endif
563         }
564 #endif
565     }
566
567   return status;
568 }
569
570 #undef DEFINE_INIT
571 #undef CHARSET_NAME
572 #undef DEFINE_FINI
573 #undef MIN_NEEDED_FROM
574 #undef MIN_NEEDED_TO
575 #undef MAX_NEEDED_FROM
576 #undef MAX_NEEDED_TO
577 #undef DEFINE_DIRECTION_OBJECTS
578 #undef FROM_DIRECTION
579 #undef EMIT_SHIFT_TO_INIT
580 #undef FROM_LOOP
581 #undef TO_LOOP
582 #undef RESET_STATE
583 #undef RESET_INPUT_BUFFER
584 #undef FUNCTION_NAME
585 #undef PREPARE_LOOP
586 #undef END_LOOP
587 #undef ONE_DIRECTION
588 #undef STORE_REST