iconv/skeleton.c

   1 /* Skeleton for a converison module.
   2    Copyright (C) 1998 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Library General Public License as
   8    published by the Free Software Foundation; either version 2 of the
   9    License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Library General Public License for more details.
  15
  16    You should have received a copy of the GNU Library General Public
  17    License along with the GNU C Library; see the file COPYING.LIB.  If not,
  18    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, USA.  */
  20
  21 /* This file 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 #include <ldsodefs.h>
  90
  91
  92 /* The direction objects.  */
  93 #if DEFINE_DIRECTION_OBJECTS || DEFINE_INIT
  94 static int from_object;
  95 static int to_object;
  96
  97 # ifndef FROM_DIRECTION
  98 #  define FROM_DIRECTION (step->data == &from_object)
  99 # endif
 100 #else
 101 # ifndef FROM_DIRECTION
 102 #  error "FROM_DIRECTION must be provided if direction objects are not used"
 103 # endif
 104 #endif
 105
 106
 107 /* How many bytes are needed at most for the from-charset.  */
 108 #ifndef MAX_NEEDED_FROM
 109 # define MAX_NEEDED_FROM        MIN_NEEDED_FROM
 110 #endif
 111
 112 /* Same for the to-charset.  */
 113 #ifndef MAX_NEEDED_TO
 114 # define MAX_NEEDED_TO          MIN_NEEDED_TO
 115 #endif
 116
 117
 118 /* For conversions from a fixed width character sets to another fixed width
 119    character set we we can define RESET_INPUT_BUFFER is necessary.  */
 120 #if !defined RESET_INPUT_BUFFER && !defined SAVE_RESET_STATE
 121 # if MIN_NEEDED_FROM == MAX_NEEDED_FROM && MIN_NEEDED_TO == MAX_NEEDED_TO
 122 /* We have to used these `if's here since the compiler cannot know that
 123    (outbuf - outerr) is always divisible by MIN_NEEDED_TO.  */
 124 #  define RESET_INPUT_BUFFER \
 125   if (MIN_NEEDED_FROM % MIN_NEEDED_TO == 0)                                   \
 126     *inbuf -= (outbuf - outerr) * (MIN_NEEDED_FROM / MIN_NEEDED_TO);          \
 127   else if (MIN_NEEDED_TO % MIN_NEEDED_FROM == 0)                              \
 128     *inbuf -= (outbuf - outerr) / (MIN_NEEDED_TO / MIN_NEEDED_FROM);          \
 129   else                                                                        \
 130     *inbuf -= ((outbuf - outerr) / MIN_NEEDED_TO) * MIN_NEEDED_FROM
 131 # endif
 132 #endif
 133
 134
 135 /* The default init function.  It simply matches the name and initializes
 136    the step data to point to one of the objects above.  */
 137 #if DEFINE_INIT
 138 # ifndef CHARSET_NAME
 139 #  error "CHARSET_NAME not defined"
 140 # endif
 141
 142 int
 143 gconv_init (struct gconv_step *step)
 144 {
 145   /* Determine which direction.  */
 146   if (__strcasecmp (step->from_name, CHARSET_NAME) == 0)
 147     step->data = &from_object;
 148   else if (__strcasecmp (step->to_name, CHARSET_NAME) == 0)
 149     step->data = &to_object;
 150   else
 151     return GCONV_NOCONV;
 152
 153   if (step->data == &from_object)
 154     {
 155       step->min_needed_from = MIN_NEEDED_FROM;
 156       step->max_needed_from = MAX_NEEDED_FROM;
 157       step->min_needed_to = MIN_NEEDED_TO;
 158       step->max_needed_to = MAX_NEEDED_TO;
 159     }
 160   else
 161     {
 162       step->min_needed_from = MIN_NEEDED_TO;
 163       step->max_needed_from = MAX_NEEDED_TO;
 164       step->min_needed_to = MIN_NEEDED_FROM;
 165       step->max_needed_to = MAX_NEEDED_FROM;
 166     }
 167
 168 #ifdef RESET_STATE
 169   step->stateful = 1;
 170 #else
 171   step->stateful = 0;
 172 #endif
 173
 174   return GCONV_OK;
 175 }
 176 #endif
 177
 178
 179 /* The default destructor function does nothing in the moment and so
 180    be define it at all.  But we still provide the macro just in case
 181    we need it some day.  */
 182 #if DEFINE_FINI
 183 #endif
 184
 185
 186 /* If no arguments have to passed to the loop function define the macro
 187    as empty.  */
 188 #ifndef EXTRA_LOOP_ARGS
 189 # define EXTRA_LOOP_ARGS
 190 #endif
 191
 192
 193 /* This is the actual conversion function.  */
 194 #ifndef FUNCTION_NAME
 195 # define FUNCTION_NAME  gconv
 196 #endif
 197
 198 int
 199 FUNCTION_NAME (struct gconv_step *step, struct gconv_step_data *data,
 200                const char **inbuf, const char *inbufend, size_t *written,
 201                int do_flush)
 202 {
 203   struct gconv_step *next_step = step + 1;
 204   struct gconv_step_data *next_data = data + 1;
 205   gconv_fct fct = next_step->fct;
 206   int status;
 207
 208   /* If the function is called with no input this means we have to reset
 209      to the initial state.  The possibly partly converted input is
 210      dropped.  */
 211   if (do_flush)
 212     {
 213       /* Call the steps down the chain if there are any.  */
 214       if (data->is_last)
 215         status = GCONV_OK;
 216       else
 217         {
 218 #ifdef EMIT_SHIFT_TO_INIT
 219           status = GCONV_OK;
 220
 221           EMIT_SHIFT_TO_INIT;
 222
 223           if (status == GCONV_OK)
 224 #endif
 225             /* Give the modules below the same chance.  */
 226             status = DL_CALL_FCT (fct, (next_step, next_data, NULL, NULL,
 227                                         written, 1));
 228         }
 229     }
 230   else
 231     {
 232       /* We preserve the initial values of the pointer variables.  */
 233       const char *inptr = *inbuf;
 234       char *outbuf = data->outbuf;
 235       char *outend = data->outbufend;
 236       char *outptr;
 237
 238       /* This variable is used to count the number of characters we
 239          actually converted.  */
 240       size_t converted = 0;
 241
 242 #ifdef PREPARE_LOOP
 243       PREPARE_LOOP
 244 #endif
 245
 246       do
 247         {
 248           /* Remember the start value for this round.  */
 249           inptr = *inbuf;
 250           /* The outbuf buffer is empty.  */
 251           outptr = outbuf;
 252
 253 #ifdef SAVE_RESET_STATE
 254           SAVE_RESET_STATE (1);
 255 #endif
 256
 257           if (FROM_DIRECTION)
 258             /* Run the conversion loop.  */
 259             status = FROM_LOOP ((const unsigned char **) inbuf,
 260                                 (const unsigned char *) inbufend,
 261                                 (unsigned char **) &outbuf,
 262                                 (unsigned char *) outend,
 263                                 data->statep, step->data, &converted
 264                                 EXTRA_LOOP_ARGS);
 265           else
 266             /* Run the conversion loop.  */
 267             status = TO_LOOP ((const unsigned char **) inbuf,
 268                               (const unsigned char *) inbufend,
 269                               (unsigned char **) &outbuf,
 270                               (unsigned char *) outend,
 271                               data->statep, step->data, &converted
 272                               EXTRA_LOOP_ARGS);
 273
 274           /* If this is the last step leave the loop, there is nothgin
 275              we can do.  */
 276           if (data->is_last)
 277             {
 278               /* Store information about how many bytes are available.  */
 279               data->outbuf = outbuf;
 280
 281               /* Remember how many characters we converted.  */
 282               *written += converted;
 283
 284               break;
 285             }
 286
 287           /* Write out all output which was produced.  */
 288           if (outbuf > outptr)
 289             {
 290               const char *outerr = data->outbuf;
 291               int result;
 292
 293               result = DL_CALL_FCT (fct, (next_step, next_data, &outerr,
 294                                           outbuf, written, 0));
 295
 296               if (result != GCONV_EMPTY_INPUT)
 297                 {
 298                   if (outerr != outbuf)
 299                     {
 300 #ifdef RESET_INPUT_BUFFER
 301                       RESET_INPUT_BUFFER;
 302 #else
 303                       /* We have a problem with the in on of the functions
 304                          below.  Undo the conversion upto the error point.  */
 305                       size_t nstatus;
 306
 307                       /* Reload the pointers.  */
 308                       *inbuf = inptr;
 309                       outbuf = outptr;
 310
 311                       /* Reset the state.  */
 312 # ifdef SAVE_RESET_STATE
 313                       SAVE_RESET_STATE (0);
 314 # endif
 315
 316                       if (FROM_DIRECTION)
 317                         /* Run the conversion loop.  */
 318                         nstatus = FROM_LOOP ((const unsigned char **) inbuf,
 319                                              (const unsigned char *) inbufend,
 320                                              (unsigned char **) &outbuf,
 321                                              (unsigned char *) outerr,
 322                                              data->statep, step->data,
 323                                              &converted EXTRA_LOOP_ARGS);
 324                       else
 325                         /* Run the conversion loop.  */
 326                         nstatus = TO_LOOP ((const unsigned char **) inbuf,
 327                                            (const unsigned char *) inbufend,
 328                                            (unsigned char **) &outbuf,
 329                                            (unsigned char *) outerr,
 330                                            data->statep, step->data,
 331                                            &converted EXTRA_LOOP_ARGS);
 332
 333                       /* We must run out of output buffer space in this
 334                          rerun.  */
 335                       assert (outbuf == outerr);
 336                       assert (nstatus == GCONV_FULL_OUTPUT);
 337 #endif  /* reset input buffer */
 338                     }
 339
 340                   /* Change the status.  */
 341                   status = result;
 342                 }
 343               else
 344                 /* All the output is consumed, we can make another run
 345                    if everything was ok.  */
 346                 if (status == GCONV_FULL_OUTPUT)
 347                   status = GCONV_OK;
 348             }
 349         }
 350       while (status == GCONV_OK);
 351
 352 #ifdef END_LOOP
 353       END_LOOP
 354 #endif
 355
 356       /* We finished one use of this step.  */
 357       ++data->invocation_counter;
 358     }
 359
 360   return status;
 361 }
 362
 363 #undef DEFINE_INIT
 364 #undef CHARSET_NAME
 365 #undef DEFINE_FINI
 366 #undef MIN_NEEDED_FROM
 367 #undef MIN_NEEDED_TO
 368 #undef MAX_NEEDED_FROM
 369 #undef MAX_NEEDED_TO
 370 #undef DEFINE_DIRECTION_OBJECTS
 371 #undef FROM_DIRECTION
 372 #undef EMIT_SHIFT_TO_INIT
 373 #undef FROM_LOOP
 374 #undef TO_LOOP
 375 #undef RESET_STATE
 376 #undef RESET_INPUT_BUFFER
 377 #undef FUNCTION_NAME
 378 #undef PREPARE_LOOP
 379 #undef END_LOOP