iconvdata/iso646.c

   1 /* Conversion to and from the various ISO 646 CCS.
   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 /* The implementation of the conversion which can be performed by this
  22    module are not very sophisticated and not tuned at all.  There are
  23    zillions of ISO 646 derivates and supporting them all in a separate
  24    module is overkill since these coded character sets are hardly ever
  25    used anymore (except ANSI_X3.4-1968 == ASCII, which is compatible
  26    with ISO 8859-1).  The European variants are superceded by the
  27    various ISO 8859-? standards and the Asian variants are embedded in
  28    larger character sets.  Therefore this implementation is simply
  29    here to make it possible to do the conversion if it is necessary.
  30    The cost in the gconv-modules file is set to `2' and therefore
  31    allows one to easily provide a tuned implementation in case this
  32    proofs to be necessary.  */
  33
  34 #include <gconv.h>
  35 #include <stdint.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38
  39 /* Definitions used in the body of the `gconv' function.  */
  40 #define FROM_LOOP               from_ascii
  41 #define TO_LOOP                 to_ascii
  42 #define DEFINE_INIT             0
  43 #define DEFINE_FINI             0
  44 #define MIN_NEEDED_FROM         1
  45 #define MIN_NEEDED_TO           4
  46 #define FROM_DIRECTION          (dir == from_iso646)
  47 #define PREPARE_LOOP \
  48   enum direction dir = ((struct iso646_data *) step->data)->dir;              \
  49   enum variant var = ((struct iso646_data *) step->data)->var;
  50 #define EXTRA_LOOP_ARGS         , var
  51
  52
  53 /* Direction of the transformation.  */
  54 enum direction
  55 {
  56   illegal_dir,
  57   to_iso646,
  58   from_iso646
  59 };
  60
  61 enum variant
  62 {
  63   illegal_var,
  64   US,           /* ANSI_X3.4-1968 */
  65   GB,           /* BS_4730 */
  66   CA,           /* CSA_Z243.4-1985-1 */
  67   CA2,          /* CSA_Z243.4-1985-2 */
  68   DE,           /* DIN_66003 */
  69   DK,           /* DS_2089 */
  70   ES,           /* ES */
  71   ES2,          /* ES2 */
  72   CN,           /* GB_1988-80 */
  73   IT,           /* IT */
  74   JP,           /* JIS_C6220-1969-RO */
  75   JP_OCR_B,     /* JIS_C6229-1984-B */
  76   YU,           /* JUS_I.B1.002 */
  77   KR,           /* KSC5636 */
  78   HU,           /* MSZ_7795.3 */
  79   CU,           /* NC_NC00-10 */
  80   FR,           /* NF_Z_62-010 */
  81   FR1,          /* NF_Z_62-010_(1973) */
  82   NO,           /* NS_4551-1 */
  83   NO2,          /* NS_4551-2 */
  84   PT,           /* PT */
  85   PT2,          /* PT2 */
  86   SE,           /* SEN_850200_B */
  87   SE2           /* SEN_850200_C */
  88 };
  89
  90 static const char *names[] =
  91 {
  92   [US] = "ANSI_X3.4-1968//",
  93   [GB] = "BS_4730//",
  94   [CA] = "CSA_Z243.4-1985-1//",
  95   [CA2] = "CSA_Z243.4-1985-2//",
  96   [DE] = "DIN_66003//",
  97   [DK] = "DS_2089//",
  98   [ES] = "ES//",
  99   [ES2] = "ES2//",
 100   [CN] = "GB_1988-80//",
 101   [IT] = "IT//",
 102   [JP] = "JIS_C6220-1969-RO//",
 103   [JP_OCR_B] = "JIS_C6229-1984-B//",
 104   [YU] = "JUS_I.B1.002//",
 105   [KR] = "KSC5636//",
 106   [HU] = "MSZ_7795.3//",
 107   [CU] = "NC_NC00-10//",
 108   [FR] = "NF_Z_62-010//",
 109   [FR1] = "NF_Z_62-010_1973//", /* Note that we don't have the parenthesis
 110                                    in the name.  */
 111   [NO] = "NS_4551-1//",
 112   [NO2] = "NS_4551-2//",
 113   [PT] = "PT//",
 114   [PT2] = "PT2//",
 115   [SE] = "SEN_850200_B//",
 116   [SE2] = "SEN_850200_C//"
 117 };
 118
 119 struct iso646_data
 120 {
 121   enum direction dir;
 122   enum variant var;
 123 };
 124
 125
 126 int
 127 gconv_init (struct gconv_step *step)
 128 {
 129   /* Determine which direction.  */
 130   struct iso646_data *new_data;
 131   enum direction dir = illegal_dir;
 132   enum variant var;
 133   int result;
 134
 135   for (var = sizeof (names) / sizeof (names[0]) - 1; var > illegal_var; --var)
 136     if (__strcasecmp (step->from_name, names[var]) == 0)
 137       {
 138         dir = from_iso646;
 139         break;
 140       }
 141     else if (__strcasecmp (step->to_name, names[var]) == 0)
 142       {
 143         dir = to_iso646;
 144         break;
 145       }
 146
 147   result = GCONV_NOCONV;
 148   if (dir != illegal_dir)
 149     {
 150       new_data = (struct iso646_data *) malloc (sizeof (struct iso646_data));
 151
 152       result = GCONV_NOMEM;
 153       if (new_data != NULL)
 154         {
 155           new_data->dir = dir;
 156           new_data->var = var;
 157           step->data = new_data;
 158
 159           if (var == from_iso646)
 160             {
 161               step->min_needed_from = MIN_NEEDED_FROM;
 162               step->max_needed_from = MIN_NEEDED_FROM;
 163               step->min_needed_to = MIN_NEEDED_TO;
 164               step->max_needed_to = MIN_NEEDED_TO;
 165             }
 166           else
 167             {
 168               step->min_needed_from = MIN_NEEDED_TO;
 169               step->max_needed_from = MIN_NEEDED_TO;
 170               step->min_needed_to = MIN_NEEDED_FROM;
 171               step->max_needed_to = MIN_NEEDED_FROM;
 172             }
 173
 174           step->stateful = 0;
 175
 176           result = GCONV_OK;
 177         }
 178     }
 179
 180   return result;
 181 }
 182
 183
 184 void
 185 gconv_end (struct gconv_step *data)
 186 {
 187   free (data->data);
 188 }
 189
 190
 191 /* First define the conversion function from ASCII to UCS4.  */
 192 #define MIN_NEEDED_INPUT        MIN_NEEDED_FROM
 193 #define MIN_NEEDED_OUTPUT       MIN_NEEDED_TO
 194 #define LOOPFCT                 FROM_LOOP
 195 #define BODY \
 196   {                                                                           \
 197     uint32_t ch;                                                              \
 198     int failure = GCONV_OK;                                                   \
 199                                                                               \
 200     ch = *inptr;                                                              \
 201     switch (ch)                                                               \
 202       {                                                                       \
 203       case 0x23:                                                              \
 204         if (var == GB || var == ES || var == IT || var == FR || var == FR1)   \
 205           ch = 0xa3;                                                          \
 206         else if (var == NO2)                                                  \
 207           ch = 0xa7;                                                          \
 208         break;                                                                \
 209       case 0x24:                                                              \
 210         if (var == CN)                                                        \
 211           ch = 0xa5;                                                          \
 212         else if (var == HU || var == CU || var == SE || var == SE2)           \
 213           ch = 0xa4;                                                          \
 214         break;                                                                \
 215       case 0x40:                                                              \
 216         if (var == CA || var == CA2 || var == FR || var == FR1)               \
 217           ch = 0xe0;                                                          \
 218         else if (var == DE || var == ES || var == IT || var == PT)            \
 219           ch = 0xa7;                                                          \
 220         else if (var == ES2)                                                  \
 221           ch = 0x2022;                                                        \
 222         else if (var == YU)                                                   \
 223           ch = 0x17d;                                                         \
 224         else if (var == HU)                                                   \
 225           ch = 0xc1;                                                          \
 226         else if (var == PT2)                                                  \
 227           ch = 0xb4;                                                          \
 228         else if (var == SE2)                                                  \
 229           ch = 0xc9;                                                          \
 230         break;                                                                \
 231       case 0x5b:                                                              \
 232         if (var == CA || var == CA2)                                          \
 233           ch = 0xe2;                                                          \
 234         else if (var == DE || var == SE || var == SE2)                        \
 235           ch = 0xc4;                                                          \
 236         else if (var == DK || var == NO || var == NO2)                        \
 237           ch = 0xc6;                                                          \
 238         else if (var == ES || var == ES2 || var == CU)                        \
 239           ch = 0xa1;                                                          \
 240         else if (var == IT || var == FR || var == FR1)                        \
 241           ch = 0xb0;                                                          \
 242         else if (var == JP_OCR_B)                                             \
 243           ch = 0x2329;                                                        \
 244         else if (var == YU)                                                   \
 245           ch = 0x160;                                                         \
 246         else if (var == HU)                                                   \
 247           ch = 0xc9;                                                          \
 248         else if (var == PT || var == PT2)                                     \
 249           ch = 0xc3;                                                          \
 250         break;                                                                \
 251       case 0x5c:                                                              \
 252         if (var == CA || var == CA2 || var == IT || var == FR || var == FR1)  \
 253           ch = 0xe7;                                                          \
 254         else if (var == DE || var == HU || var == SE || var == SE2)           \
 255           ch = 0xd6;                                                          \
 256         else if (var == DK || var == NO || var == NO2)                        \
 257           ch = 0xd8;                                                          \
 258         else if (var == ES || var == ES2 || var == CU)                        \
 259           ch = 0xd1;                                                          \
 260         else if (var == JP || var == JP_OCR_B)                                \
 261           ch = 0xa5;                                                          \
 262         else if (var == YU)                                                   \
 263           ch = 0x110;                                                         \
 264         else if (var == KR)                                                   \
 265           ch = 0x20a9;                                                        \
 266         else if (var == PT || var == PT2)                                     \
 267           ch = 0xc7;                                                          \
 268         break;                                                                \
 269       case 0x5d:                                                              \
 270         if (var == CA || var == CA2)                                          \
 271           ch = 0xea;                                                          \
 272         else if (var == DE || var == HU)                                      \
 273           ch = 0xdc;                                                          \
 274         else if (var == DK || var == NO || var == NO2 || var == SE            \
 275                  || var == SE2)                                               \
 276           ch = 0xc5;                                                          \
 277         else if (var == ES)                                                   \
 278           ch = 0xbf;                                                          \
 279         else if (var == ES2)                                                  \
 280           ch = 0xc7;                                                          \
 281         else if (var == IT)                                                   \
 282           ch = 0xe9;                                                          \
 283         else if (var == JP_OCR_B)                                             \
 284           ch = 0x232a;                                                        \
 285         else if (var == YU)                                                   \
 286           ch = 0x106;                                                         \
 287         else if (var == FR || var == FR1)                                     \
 288           ch = 0xa7;                                                          \
 289         else if (var == PT || var == PT2)                                     \
 290           ch = 0xd5;                                                          \
 291         break;                                                                \
 292       case 0x5e:                                                              \
 293         if (var == CA)                                                        \
 294           ch = 0xee;                                                          \
 295         else if (var == CA2)                                                  \
 296           ch = 0xc9;                                                          \
 297         else if (var == ES2 || var == CU)                                     \
 298           ch = 0xbf;                                                          \
 299         else if (var == YU)                                                   \
 300           ch = 0x10c;                                                         \
 301         else if (var == SE2)                                                  \
 302           ch = 0xdc;                                                          \
 303         break;                                                                \
 304       case 0x60:                                                              \
 305         if (var == CA || var == CA2)                                          \
 306           ch = 0xf4;                                                          \
 307         else if (var == IT)                                                   \
 308           ch = 0xf9;                                                          \
 309         else if (var == JP_OCR_B)                                             \
 310           /* Illegal character.  */                                           \
 311           failure = GCONV_ILLEGAL_INPUT;                                      \
 312         else if (var == YU)                                                   \
 313           ch = 0x17e;                                                         \
 314         else if (var == HU)                                                   \
 315           ch = 0xe1;                                                          \
 316         else if (var == FR)                                                   \
 317           ch = 0xb5;                                                          \
 318         else if (var == SE2)                                                  \
 319           ch = 0xe9;                                                          \
 320         break;                                                                \
 321       case 0x7b:                                                              \
 322         if (var == CA || var == CA2 || var == HU || var == FR || var == FR1)  \
 323           ch = 0xe9;                                                          \
 324         else if (var == DE || var == SE || var == SE2)                        \
 325           ch = 0xe4;                                                          \
 326         else if (var == DK || var == NO || var == NO2)                        \
 327           ch = 0xe6;                                                          \
 328         else if (var == ES)                                                   \
 329           ch = 0xb0;                                                          \
 330         else if (var == ES2 || var == CU)                                     \
 331           ch = 0xb4;                                                          \
 332         else if (var == IT)                                                   \
 333           ch = 0xe0;                                                          \
 334         else if (var == YU)                                                   \
 335           ch = 0x161;                                                         \
 336         else if (var == PT || var == PT2)                                     \
 337           ch = 0xe3;                                                          \
 338         break;                                                                \
 339       case 0x7c:                                                              \
 340         if (var == CA || var == CA2 || var == FR || var == FR1)               \
 341           ch = 0xf9;                                                          \
 342         else if (var == DE || var == HU || var == SE || var == SE2)           \
 343           ch = 0xf6;                                                          \
 344         else if (var == DK || var == NO || var == NO2)                        \
 345           ch = 0xf8;                                                          \
 346         else if (var == ES || var == ES2 || var == CU)                        \
 347           ch = 0xf1;                                                          \
 348         else if (var == IT)                                                   \
 349           ch = 0xf2;                                                          \
 350         else if (var == YU)                                                   \
 351           ch = 0x111;                                                         \
 352         else if (var == PT || var == PT2)                                     \
 353           ch = 0xe7;                                                          \
 354         break;                                                                \
 355       case 0x7d:                                                              \
 356         if (var == CA || var == CA2 || var == IT || var == FR || var == FR1)  \
 357           ch = 0xe8;                                                          \
 358         else if (var == DE || var == HU)                                      \
 359           ch = 0xfc;                                                          \
 360         else if (var == DK || var == NO || var == NO2 || var == SE            \
 361                  || var == SE2)                                               \
 362           ch = 0xe5;                                                          \
 363         else if (var == ES || var == ES2)                                     \
 364           ch = 0xe7;                                                          \
 365         else if (var == YU)                                                   \
 366           ch = 0x107;                                                         \
 367         else if (var == CU)                                                   \
 368           ch = 0x5b;                                                          \
 369         else if (var == PT || var == PT2)                                     \
 370           ch = 0xf5;                                                          \
 371         break;                                                                \
 372       case 0x7e:                                                              \
 373         if (var == GB || var == CN || var == JP || var == NO || var == SE)    \
 374           ch = 0x203e;                                                        \
 375         else if (var == CA || var == CA2)                                     \
 376           ch = 0xfb;                                                          \
 377         else if (var == DE)                                                   \
 378           ch = 0xdf;                                                          \
 379         else if (var == ES2 || var == CU || var == FR || var == FR1)          \
 380           ch = 0xa8;                                                          \
 381         else if (var == IT)                                                   \
 382           ch = 0xec;                                                          \
 383         else if (var == JP_OCR_B)                                             \
 384           /* Illegal character.  */                                           \
 385           failure = GCONV_ILLEGAL_INPUT;                                      \
 386         else if (var == YU)                                                   \
 387           ch = 0x10d;                                                         \
 388         else if (var == HU)                                                   \
 389           ch = 0x2dd;                                                         \
 390         else if (var == NO2)                                                  \
 391           ch = 0x7c;                                                          \
 392         else if (var == PT)                                                   \
 393           ch = 0xb0;                                                          \
 394         else if (var == SE2)                                                  \
 395           ch = 0xfc;                                                          \
 396         break;                                                                \
 397       default:                                                                \
 398         break;                                                                \
 399       case 0x80 ... 0xff:                                                     \
 400         /* Illegal character.  */                                             \
 401         failure = GCONV_ILLEGAL_INPUT;                                        \
 402         break;                                                                \
 403       }                                                                       \
 404                                                                               \
 405     /* Hopefully gcc can recognize that the following `if' is only true       \
 406        when we reach the default case in the `switch' statement.  */          \
 407     if (failure == GCONV_ILLEGAL_INPUT)                                       \
 408       {                                                                       \
 409         /* Exit the loop with an error.  */                                   \
 410         result = failure;                                                     \
 411         break;                                                                \
 412       }                                                                       \
 413     *((uint32_t *) outptr)++ = ch;                                            \
 414     ++inptr;                                                                  \
 415   }
 416 #define EXTRA_LOOP_DECLS        , enum variant var
 417 #include <iconv/loop.c>
 418
 419
 420 /* Next, define the other direction.  */
 421 #define MIN_NEEDED_INPUT        MIN_NEEDED_TO
 422 #define MIN_NEEDED_OUTPUT       MIN_NEEDED_FROM
 423 #define LOOPFCT                 TO_LOOP
 424 #define BODY \
 425   {                                                                           \
 426     unsigned char ch;                                                         \
 427     int failure = GCONV_OK;                                                   \
 428                                                                               \
 429     ch = *((uint32_t *) inptr);                                               \
 430     switch (*((uint32_t *) inptr))                                            \
 431       {                                                                       \
 432       case 0x23:                                                              \
 433         if (var == GB || var == ES || var == IT || var == FR || var == FR1    \
 434             || var == NO2)                                                    \
 435           failure = GCONV_ILLEGAL_INPUT;                                      \
 436         break;                                                                \
 437       case 0x24:                                                              \
 438         if (var == CN || var == HU || var == CU || var == SE || var == SE2)   \
 439           failure = GCONV_ILLEGAL_INPUT;                                      \
 440         break;                                                                \
 441       case 0x40:                                                              \
 442         if (var == CA || var == CA2 || var == DE || var == ES || var == ES2   \
 443             || var == IT || var == YU || var == HU || var == FR || var == FR1 \
 444             || var == PT || var == PT2 || var == SE2)                         \
 445           failure = GCONV_ILLEGAL_INPUT;                                      \
 446         break;                                                                \
 447       case 0x5b:                                                              \
 448         if (var == CA || var == CA2 || var == DE || var == DK || var == ES    \
 449             || var == ES2 || var == IT || var == JP_OCR_B || var == YU        \
 450             || var == HU || var == FR || var == FR1 || var == NO              \
 451             || var == NO2 || var == PT || var == PT2 || var == SE             \
 452             || var == SE2)                                                    \
 453           failure = GCONV_ILLEGAL_INPUT;                                      \
 454         else if (var == CU)                                                   \
 455           ch = 0x7d;                                                          \
 456         break;                                                                \
 457       case 0x5c:                                                              \
 458         if (var == CA || var == CA2 || var == DE || var == DK || var == ES    \
 459             || var == ES2 || var == IT || var == JP || var == JP_OCR_B        \
 460             || var == YU || var == KR || var == HU || var == CU || var == FR  \
 461             || var == FR1 || var == NO || var == NO2 || var == PT             \
 462             || var == PT2 || var == SE || var == SE2)                         \
 463           failure = GCONV_ILLEGAL_INPUT;                                      \
 464         break;                                                                \
 465       case 0x5d:                                                              \
 466         if (var == CA || var == CA2 || var == DE || var == DK || var == ES    \
 467             || var == ES2 || var == IT || var == JP_OCR_B || var == YU        \
 468             || var == HU || var == FR || var == FR1 || var == NO              \
 469             || var == NO2 || var == PT || var == PT2 || var == SE             \
 470             || var == SE2)                                                    \
 471           failure = GCONV_ILLEGAL_INPUT;                                      \
 472         break;                                                                \
 473       case 0x5e:                                                              \
 474         if (var == CA || var == CA2 || var == ES2 || var == YU || var == CU   \
 475             || var == SE2)                                                    \
 476           failure = GCONV_ILLEGAL_INPUT;                                      \
 477         break;                                                                \
 478       case 0x60:                                                              \
 479         if (var == CA || var == CA2 || var == IT || var == JP_OCR_B           \
 480             || var == YU || var == HU || var == FR || var == SE2)             \
 481           failure = GCONV_ILLEGAL_INPUT;                                      \
 482         break;                                                                \
 483       case 0x7b:                                                              \
 484         if (var == CA || var == CA2 || var == DE || var == DK || var == ES    \
 485             || var == ES2 || var == IT || var == YU || var == HU              \
 486             || var == CU || var == FR || var == FR1 || var == NO              \
 487             || var == NO2 || var == PT || var == PT2 || var == SE             \
 488             || var == SE2)                                                    \
 489           failure = GCONV_ILLEGAL_INPUT;                                      \
 490         break;                                                                \
 491       case 0x7c:                                                              \
 492         if (var == CA || var == CA2 || var == DE || var == DK || var == ES    \
 493             || var == ES2 || var == IT || var == YU || var == HU || var == CU \
 494             || var == FR || var == FR1 || var == NO || var == PT              \
 495             || var == PT2 || var == SE || var == SE2)                         \
 496           failure = GCONV_ILLEGAL_INPUT;                                      \
 497         else if (var == NO2)                                                  \
 498           ch = 0x7e;                                                          \
 499         break;                                                                \
 500       case 0x7d:                                                              \
 501         if (var == CA || var == CA2 || var == DE || var == DK || var == ES    \
 502             || var == ES2 || var == IT || var == YU || var == HU || var == CU \
 503             || var == FR || var == FR1 || var == NO || var == NO2             \
 504             || var == PT || var == PT2 || var == SE || var == SE2)            \
 505           failure = GCONV_ILLEGAL_INPUT;                                      \
 506         break;                                                                \
 507       case 0x7e:                                                              \
 508         if (var == GB || var == CA || var == CA2 || var == DE || var == ES2   \
 509             || var == CN || var == IT || var == JP || var == JP_OCR_B         \
 510             || var == YU || var == HU || var == CU || var == FR || var == FR1 \
 511             || var == NO || var == NO2 || var == PT || var == SE              \
 512             || var == SE2)                                                    \
 513           failure = GCONV_ILLEGAL_INPUT;                                      \
 514         break;                                                                \
 515       case 0xa1:                                                              \
 516         if (var != ES && var != ES2 && var != CU)                             \
 517           failure = GCONV_ILLEGAL_INPUT;                                      \
 518         ch = 0x5b;                                                            \
 519         break;                                                                \
 520       case 0xa3:                                                              \
 521         if (var != GB && var != ES && var != IT && var != FR && var != FR1)   \
 522           failure = GCONV_ILLEGAL_INPUT;                                      \
 523         ch = 0x23;                                                            \
 524         break;                                                                \
 525       case 0xa4:                                                              \
 526         if (var != HU && var != CU && var != SE && var != SE2)                \
 527           failure = GCONV_ILLEGAL_INPUT;                                      \
 528         ch = 0x24;                                                            \
 529         break;                                                                \
 530       case 0xa5:                                                              \
 531         if (var == CN)                                                        \
 532           ch = 0x24;                                                          \
 533         else if (var == JP || var == JP_OCR_B)                                \
 534           ch = 0x5c;                                                          \
 535         else                                                                  \
 536           failure = GCONV_ILLEGAL_INPUT;                                      \
 537         break;                                                                \
 538       case 0xa7:                                                              \
 539         if (var == DE || var == ES || var == IT || var == PT)                 \
 540           ch = 0x40;                                                          \
 541         else if (var == FR || var == FR1)                                     \
 542           ch = 0x5d;                                                          \
 543         else if (var == NO2)                                                  \
 544           ch = 0x23;                                                          \
 545         else                                                                  \
 546           failure = GCONV_ILLEGAL_INPUT;                                      \
 547         break;                                                                \
 548       case 0xa8:                                                              \
 549         if (var != ES2 && var != CU && var != FR && var != FR1)               \
 550           failure = GCONV_ILLEGAL_INPUT;                                      \
 551         ch = 0x7e;                                                            \
 552         break;                                                                \
 553       case 0xb0:                                                              \
 554         if (var == ES)                                                        \
 555           ch = 0x7b;                                                          \
 556         else if (var == IT || var == FR || var == FR1)                        \
 557           ch = 0x5b;                                                          \
 558         else if (var == PT)                                                   \
 559           ch = 0x7e;                                                          \
 560         else                                                                  \
 561           failure = GCONV_ILLEGAL_INPUT;                                      \
 562         break;                                                                \
 563       case 0xb4:                                                              \
 564         if (var == ES2 || var == CU)                                          \
 565           ch = 0x7b;                                                          \
 566         else if (var == PT2)                                                  \
 567           ch = 0x40;                                                          \
 568         else                                                                  \
 569           failure = GCONV_ILLEGAL_INPUT;                                      \
 570         break;                                                                \
 571       case 0xb5:                                                              \
 572         if (var != FR)                                                        \
 573           failure = GCONV_ILLEGAL_INPUT;                                      \
 574         ch = 0x60;                                                            \
 575         break;                                                                \
 576       case 0xbf:                                                              \
 577         if (var == ES)                                                        \
 578           ch = 0x5d;                                                          \
 579         else if (var == ES2 || var == CU)                                     \
 580           ch = 0x5e;                                                          \
 581         else                                                                  \
 582           failure = GCONV_ILLEGAL_INPUT;                                      \
 583         break;                                                                \
 584       case 0xc1:                                                              \
 585         if (var != HU)                                                        \
 586           failure = GCONV_ILLEGAL_INPUT;                                      \
 587         ch = 0x40;                                                            \
 588         break;                                                                \
 589       case 0xc3:                                                              \
 590         if (var != PT && var != PT2)                                          \
 591           failure = GCONV_ILLEGAL_INPUT;                                      \
 592         ch = 0x5b;                                                            \
 593         break;                                                                \
 594       case 0xc4:                                                              \
 595         if (var != DE && var != SE && var != SE2)                             \
 596           failure = GCONV_ILLEGAL_INPUT;                                      \
 597         ch = 0x5b;                                                            \
 598         break;                                                                \
 599       case 0xc5:                                                              \
 600         if (var != DK && var != NO && var != NO2 && var != SE && var != SE2)  \
 601           failure = GCONV_ILLEGAL_INPUT;                                      \
 602         ch = 0x5d;                                                            \
 603         break;                                                                \
 604       case 0xc6:                                                              \
 605         if (var != DK && var != NO && var != NO2)                             \
 606           failure = GCONV_ILLEGAL_INPUT;                                      \
 607         ch = 0x5b;                                                            \
 608         break;                                                                \
 609       case 0xc7:                                                              \
 610         if (var == ES2)                                                       \
 611           ch = 0x5d;                                                          \
 612         else if (var == PT || var == PT2)                                     \
 613           ch = 0x5c;                                                          \
 614         else                                                                  \
 615           failure = GCONV_ILLEGAL_INPUT;                                      \
 616         break;                                                                \
 617       case 0xc9:                                                              \
 618         if (var == CA2)                                                       \
 619           ch = 0x5e;                                                          \
 620         else if (var == HU)                                                   \
 621           ch = 0x5b;                                                          \
 622         else if (var == SE2)                                                  \
 623           ch = 0x40;                                                          \
 624         else                                                                  \
 625           failure = GCONV_ILLEGAL_INPUT;                                      \
 626         break;                                                                \
 627       case 0xd1:                                                              \
 628         if (var != ES && var != ES2 && var != CU)                             \
 629           failure = GCONV_ILLEGAL_INPUT;                                      \
 630         ch = 0x5c;                                                            \
 631         break;                                                                \
 632       case 0xd5:                                                              \
 633         if (var != PT && var != PT2)                                          \
 634           failure = GCONV_ILLEGAL_INPUT;                                      \
 635         ch = 0x5d;                                                            \
 636         break;                                                                \
 637       case 0xd6:                                                              \
 638         if (var != DE && var != HU && var != SE && var != SE2)                \
 639           failure = GCONV_ILLEGAL_INPUT;                                      \
 640         ch = 0x5c;                                                            \
 641         break;                                                                \
 642       case 0xd8:                                                              \
 643         if (var != DK && var != NO && var != NO2)                             \
 644           failure = GCONV_ILLEGAL_INPUT;                                      \
 645         ch = 0x5c;                                                            \
 646         break;                                                                \
 647       case 0xdc:                                                              \
 648         if (var == DE || var == HU)                                           \
 649           ch = 0x5d;                                                          \
 650         else if (var == SE2)                                                  \
 651           ch = 0x5e;                                                          \
 652         else                                                                  \
 653           failure = GCONV_ILLEGAL_INPUT;                                      \
 654         break;                                                                \
 655       case 0xdf:                                                              \
 656         if (var != DE)                                                        \
 657           failure = GCONV_ILLEGAL_INPUT;                                      \
 658         ch = 0x7e;                                                            \
 659         break;                                                                \
 660       case 0xe0:                                                              \
 661         if (var == CA || var == CA2 || var == FR || var == FR1)               \
 662           ch = 0x40;                                                          \
 663         else if (var == IT)                                                   \
 664           ch = 0x7b;                                                          \
 665         else                                                                  \
 666           failure = GCONV_ILLEGAL_INPUT;                                      \
 667         break;                                                                \
 668       case 0xe1:                                                              \
 669         if (var != HU)                                                        \
 670           failure = GCONV_ILLEGAL_INPUT;                                      \
 671         ch = 0x60;                                                            \
 672         break;                                                                \
 673       case 0xe2:                                                              \
 674         if (var != CA && var != CA2)                                          \
 675           failure = GCONV_ILLEGAL_INPUT;                                      \
 676         ch = 0x5b;                                                            \
 677         break;                                                                \
 678       case 0xe3:                                                              \
 679         if (var != PT && var != PT2)                                          \
 680           failure = GCONV_ILLEGAL_INPUT;                                      \
 681         ch = 0x7b;                                                            \
 682         break;                                                                \
 683       case 0xe4:                                                              \
 684         if (var != DE && var != SE && var != SE2)                             \
 685           failure = GCONV_ILLEGAL_INPUT;                                      \
 686         ch = 0x7b;                                                            \
 687         break;                                                                \
 688       case 0xe5:                                                              \
 689         if (var != DK && var != NO && var != NO2 && var != SE && var != SE2)  \
 690           failure = GCONV_ILLEGAL_INPUT;                                      \
 691         ch = 0x7d;                                                            \
 692         break;                                                                \
 693       case 0xe6:                                                              \
 694         if (var != DK && var != NO && var != NO2)                             \
 695           failure = GCONV_ILLEGAL_INPUT;                                      \
 696         ch = 0x7b;                                                            \
 697         break;                                                                \
 698       case 0xe7:                                                              \
 699         if (var == CA || var == CA2 || var == IT || var == FR || var == FR1)  \
 700           ch = 0x5c;                                                          \
 701         else if (var == ES || var == ES2)                                     \
 702           ch = 0x7d;                                                          \
 703         else if (var == PT || var == PT2)                                     \
 704           ch = 0x7c;                                                          \
 705         else                                                                  \
 706           failure = GCONV_ILLEGAL_INPUT;                                      \
 707         break;                                                                \
 708       case 0xe8:                                                              \
 709         if (var != CA && var != CA2 && var != IT && var != FR && var != FR1)  \
 710           failure = GCONV_ILLEGAL_INPUT;                                      \
 711         ch = 0x7d;                                                            \
 712         break;                                                                \
 713       case 0xe9:                                                              \
 714         if (var == CA || var == CA2 || var == HU || var == FR || var == FR1)  \
 715           ch = 0x7b;                                                          \
 716         else if (var == IT)                                                   \
 717           ch = 0x5d;                                                          \
 718         else if (var == SE2)                                                  \
 719           ch = 0x60;                                                          \
 720         else                                                                  \
 721           failure = GCONV_ILLEGAL_INPUT;                                      \
 722         break;                                                                \
 723       case 0xea:                                                              \
 724         if (var != CA && var != CA2)                                          \
 725           failure = GCONV_ILLEGAL_INPUT;                                      \
 726         ch = 0x5d;                                                            \
 727         break;                                                                \
 728       case 0xec:                                                              \
 729         if (var != IT)                                                        \
 730           failure = GCONV_ILLEGAL_INPUT;                                      \
 731         ch = 0x7e;                                                            \
 732         break;                                                                \
 733       case 0xee:                                                              \
 734         if (var != CA)                                                        \
 735           failure = GCONV_ILLEGAL_INPUT;                                      \
 736         ch = 0x5e;                                                            \
 737         break;                                                                \
 738       case 0xf1:                                                              \
 739         if (var != ES && var != ES2 && var != CU)                             \
 740           failure = GCONV_ILLEGAL_INPUT;                                      \
 741         ch = 0x7c;                                                            \
 742         break;                                                                \
 743       case 0xf2:                                                              \
 744         if (var != IT)                                                        \
 745           failure = GCONV_ILLEGAL_INPUT;                                      \
 746         ch = 0x7c;                                                            \
 747         break;                                                                \
 748       case 0xf4:                                                              \
 749         if (var != CA && var != CA2)                                          \
 750           failure = GCONV_ILLEGAL_INPUT;                                      \
 751         ch = 0x60;                                                            \
 752         break;                                                                \
 753       case 0xf5:                                                              \
 754         if (var != PT && var != PT2)                                          \
 755           failure = GCONV_ILLEGAL_INPUT;                                      \
 756         ch = 0x7d;                                                            \
 757         break;                                                                \
 758       case 0xf6:                                                              \
 759         if (var != DE && var != HU && var != SE && var != SE2)                \
 760           failure = GCONV_ILLEGAL_INPUT;                                      \
 761         ch = 0x7c;                                                            \
 762         break;                                                                \
 763       case 0xf8:                                                              \
 764         if (var != DK && var != NO && var != NO2)                             \
 765           failure = GCONV_ILLEGAL_INPUT;                                      \
 766         ch = 0x7c;                                                            \
 767         break;                                                                \
 768       case 0xf9:                                                              \
 769         if (var == CA || var == CA2 || var == FR || var == FR1)               \
 770           ch = 0x7c;                                                          \
 771         else if (var == IT)                                                   \
 772           ch = 0x60;                                                          \
 773         else                                                                  \
 774           failure = GCONV_ILLEGAL_INPUT;                                      \
 775         break;                                                                \
 776       case 0xfb:                                                              \
 777         if (var != CA && var != CA2)                                          \
 778           failure = GCONV_ILLEGAL_INPUT;                                      \
 779         ch = 0x7e;                                                            \
 780         break;                                                                \
 781       case 0xfc:                                                              \
 782         if (var == DE || var == HU)                                           \
 783           ch = 0x7d;                                                          \
 784         else if (var == SE2)                                                  \
 785           ch = 0x7e;                                                          \
 786         else                                                                  \
 787           failure = GCONV_ILLEGAL_INPUT;                                      \
 788         break;                                                                \
 789       case 0x160:                                                             \
 790         if (var != YU)                                                        \
 791           failure = GCONV_ILLEGAL_INPUT;                                      \
 792         ch = 0x5b;                                                            \
 793         break;                                                                \
 794       case 0x106:                                                             \
 795         if (var != YU)                                                        \
 796           failure = GCONV_ILLEGAL_INPUT;                                      \
 797         ch = 0x5d;                                                            \
 798         break;                                                                \
 799       case 0x107:                                                             \
 800         if (var != YU)                                                        \
 801           failure = GCONV_ILLEGAL_INPUT;                                      \
 802         ch = 0x7d;                                                            \
 803         break;                                                                \
 804       case 0x10c:                                                             \
 805         if (var != YU)                                                        \
 806           failure = GCONV_ILLEGAL_INPUT;                                      \
 807         ch = 0x5e;                                                            \
 808         break;                                                                \
 809       case 0x10d:                                                             \
 810         if (var != YU)                                                        \
 811           failure = GCONV_ILLEGAL_INPUT;                                      \
 812         ch = 0x7e;                                                            \
 813         break;                                                                \
 814       case 0x110:                                                             \
 815         if (var != YU)                                                        \
 816           failure = GCONV_ILLEGAL_INPUT;                                      \
 817         ch = 0x5c;                                                            \
 818         break;                                                                \
 819       case 0x111:                                                             \
 820         if (var != YU)                                                        \
 821           failure = GCONV_ILLEGAL_INPUT;                                      \
 822         ch = 0x7c;                                                            \
 823         break;                                                                \
 824       case 0x161:                                                             \
 825         if (var != YU)                                                        \
 826           failure = GCONV_ILLEGAL_INPUT;                                      \
 827         ch = 0x7b;                                                            \
 828         break;                                                                \
 829       case 0x17d:                                                             \
 830         if (var != YU)                                                        \
 831           failure = GCONV_ILLEGAL_INPUT;                                      \
 832         ch = 0x40;                                                            \
 833         break;                                                                \
 834       case 0x17e:                                                             \
 835         if (var != YU)                                                        \
 836           failure = GCONV_ILLEGAL_INPUT;                                      \
 837         ch = 0x60;                                                            \
 838         break;                                                                \
 839       case 0x2dd:                                                             \
 840         if (var != HU)                                                        \
 841           failure = GCONV_ILLEGAL_INPUT;                                      \
 842         ch = 0x7e;                                                            \
 843         break;                                                                \
 844       case 0x2022:                                                            \
 845         if (var != ES2)                                                       \
 846           failure = GCONV_ILLEGAL_INPUT;                                      \
 847         ch = 0x40;                                                            \
 848         break;                                                                \
 849       case 0x203e:                                                            \
 850         if (var != GB && var != CN && var != JP && var != NO && var != SE)    \
 851           failure = GCONV_ILLEGAL_INPUT;                                      \
 852         ch = 0x7e;                                                            \
 853         break;                                                                \
 854       case 0x20a9:                                                            \
 855         if (var != KR)                                                        \
 856           failure = GCONV_ILLEGAL_INPUT;                                      \
 857         ch = 0x5c;                                                            \
 858         break;                                                                \
 859       case 0x2329:                                                            \
 860         if (var != JP_OCR_B)                                                  \
 861           failure = GCONV_ILLEGAL_INPUT;                                      \
 862         ch = 0x5b;                                                            \
 863         break;                                                                \
 864       case 0x232a:                                                            \
 865         if (var != JP_OCR_B)                                                  \
 866           failure = GCONV_ILLEGAL_INPUT;                                      \
 867         ch = 0x5d;                                                            \
 868         break;                                                                \
 869       default:                                                                \
 870         if (*((uint32_t *) inptr) > 0x7f)                                     \
 871           failure = GCONV_ILLEGAL_INPUT;                                      \
 872         break;                                                                \
 873       }                                                                       \
 874                                                                               \
 875     if (failure == GCONV_ILLEGAL_INPUT)                                       \
 876       {                                                                       \
 877         /* Exit the loop with an error.  */                                   \
 878         result = failure;                                                     \
 879         break;                                                                \
 880       }                                                                       \
 881     *outptr++ = (unsigned char) ch;                                           \
 882     inptr += 4;                                                               \
 883   }
 884 #define EXTRA_LOOP_DECLS        , enum variant var
 885 #include <iconv/loop.c>
 886
 887
 888 /* Now define the toplevel functions.  */
 889 #include <iconv/skeleton.c>