iconvdata/tst-table-from.c

   1 /* Copyright (C) 2000 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Bruno Haible <haible@clisp.cons.org>, 2000.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Library General Public License as
   7    published by the Free Software Foundation; either version 2 of the
   8    License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Library General Public License for more details.
  14
  15    You should have received a copy of the GNU Library General Public
  16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
  17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18    Boston, MA 02111-1307, USA.  */
  19
  20 /* Create a table from CHARSET to Unicode.
  21    This is a good test for CHARSET's iconv() module, in particular the
  22    FROM_LOOP BODY macro.  */
  23
  24 #include <stddef.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <iconv.h>
  29 #include <errno.h>
  30
  31 /* Converts a byte buffer to a hexadecimal string.  */
  32 static const char*
  33 hexbuf (unsigned char buf[], unsigned int buflen)
  34 {
  35   static char msg[50];
  36
  37   switch (buflen)
  38     {
  39     case 1:
  40       sprintf (msg, "0x%02X", buf[0]);
  41       break;
  42     case 2:
  43       sprintf (msg, "0x%02X%02X", buf[0], buf[1]);
  44       break;
  45     case 3:
  46       sprintf (msg, "0x%02X%02X%02X", buf[0], buf[1], buf[2]);
  47       break;
  48     case 4:
  49       sprintf (msg, "0x%02X%02X%02X%02X", buf[0], buf[1], buf[2], buf[3]);
  50       break;
  51     default:
  52       abort ();
  53     }
  54   return msg;
  55 }
  56
  57 /* Attempts to convert a byte buffer BUF (BUFLEN bytes) to OUT (6 bytes)
  58    using the conversion descriptor CD.  Returns the number of written bytes,
  59    or 0 if ambiguous, or -1 if invalid.  */
  60 static int
  61 try (iconv_t cd, unsigned char buf[], unsigned int buflen, unsigned char *out)
  62 {
  63   const char *inbuf = (const char *) buf;
  64   size_t inbytesleft = buflen;
  65   char *outbuf = (char *) out;
  66   size_t outbytesleft = 6;
  67   size_t result = iconv (cd,
  68                          (char **) &inbuf, &inbytesleft,
  69                          &outbuf, &outbytesleft);
  70   if (result == (size_t)(-1))
  71     {
  72       if (errno == EILSEQ)
  73         {
  74           return -1;
  75         }
  76       else if (errno == EINVAL)
  77         {
  78           return 0;
  79         }
  80       else
  81         {
  82           int saved_errno = errno;
  83           fprintf (stderr, "%s: iconv error: ", hexbuf (buf, buflen));
  84           errno = saved_errno;
  85           perror ("");
  86           exit (1);
  87         }
  88     }
  89   else
  90     {
  91       if (inbytesleft != 0)
  92         {
  93           fprintf (stderr, "%s: inbytes = %ld, outbytes = %ld\n",
  94                    hexbuf (buf, buflen),
  95                    (long) (buflen - inbytesleft),
  96                    (long) (6 - outbytesleft));
  97           exit (1);
  98         }
  99       return 6 - outbytesleft;
 100     }
 101 }
 102
 103 /* Returns the out[] buffer as a Unicode value.  */
 104 static unsigned int
 105 utf8_decode (const unsigned char *out, unsigned int outlen)
 106 {
 107   return (outlen==1 ? out[0] :
 108           outlen==2 ? ((out[0] & 0x1f) << 6) + (out[1] & 0x3f) :
 109           outlen==3 ? ((out[0] & 0x0f) << 12) + ((out[1] & 0x3f) << 6) + (out[2] & 0x3f) :
 110           outlen==4 ? ((out[0] & 0x07) << 18) + ((out[1] & 0x3f) << 12) + ((out[2] & 0x3f) << 6) + (out[3] & 0x3f) :
 111           outlen==5 ? ((out[0] & 0x03) << 24) + ((out[1] & 0x3f) << 18) + ((out[2] & 0x3f) << 12) + ((out[3] & 0x3f) << 6) + (out[4] & 0x3f) :
 112           outlen==6 ? ((out[0] & 0x01) << 30) + ((out[1] & 0x3f) << 24) + ((out[2] & 0x3f) << 18) + ((out[3] & 0x3f) << 12) + ((out[4] & 0x3f) << 6) + (out[5] & 0x3f) :
 113           0xfffd);
 114 }
 115
 116 int
 117 main (int argc, char *argv[])
 118 {
 119   const char *charset;
 120   iconv_t cd;
 121
 122   if (argc != 2)
 123     {
 124       fprintf (stderr, "Usage: tst-table-to charset\n");
 125       exit (1);
 126     }
 127   charset = argv[1];
 128
 129   cd = iconv_open ("UTF-8", charset);
 130   if (cd == (iconv_t)(-1))
 131     {
 132       perror ("iconv_open");
 133       exit (1);
 134     }
 135
 136   {
 137     unsigned char out[6];
 138     unsigned char buf[4];
 139     unsigned int i0, i1, i2, i3;
 140     int result;
 141
 142     for (i0 = 0; i0 < 0x100; i0++)
 143       {
 144         buf[0] = i0;
 145         result = try (cd, buf, 1, out);
 146         if (result < 0)
 147           {
 148           }
 149         else if (result > 0)
 150           {
 151             printf ("0x%02X\t0x%04X\n",
 152                     i0, utf8_decode (out, result));
 153           }
 154         else
 155           {
 156             for (i1 = 0; i1 < 0x100; i1++)
 157               {
 158                 buf[1] = i1;
 159                 result = try (cd, buf, 2, out);
 160                 if (result < 0)
 161                   {
 162                   }
 163                 else if (result > 0)
 164                   {
 165                     printf ("0x%02X%02X\t0x%04X\n",
 166                             i0, i1, utf8_decode (out, result));
 167                   }
 168                 else
 169                   {
 170                     for (i2 = 0; i2 < 0x100; i2++)
 171                       {
 172                         buf[2] = i2;
 173                         result = try (cd, buf, 3, out);
 174                         if (result < 0)
 175                           {
 176                           }
 177                         else if (result > 0)
 178                           {
 179                             printf ("0x%02X%02X%02X\t0x%04X\n",
 180                                     i0, i1, i2, utf8_decode (out, result));
 181                           }
 182                         else if (strcmp (charset, "UTF-8"))
 183                           {
 184                             for (i3 = 0; i3 < 0x100; i3++)
 185                               {
 186                                 buf[3] = i3;
 187                                 result = try (cd, buf, 4, out);
 188                                 if (result < 0)
 189                                   {
 190                                   }
 191                                 else if (result > 0)
 192                                   {
 193                                     printf ("0x%02X%02X%02X%02X\t0x%04X\n",
 194                                             i0, i1, i2, i3,
 195                                             utf8_decode (out, result));
 196                                   }
 197                                 else
 198                                   {
 199                                     fprintf (stderr,
 200                                              "%s: incomplete byte sequence\n",
 201                                              hexbuf (buf, 4));
 202                                     exit (1);
 203                                   }
 204                               }
 205                           }
 206                       }
 207                   }
 208               }
 209           }
 210       }
 211   }
 212
 213   if (iconv_close (cd) < 0)
 214     {
 215       perror ("iconv_close");
 216       exit (1);
 217     }
 218
 219   if (ferror (stdin) || ferror (stdout))
 220     {
 221       fprintf (stderr, "I/O error\n");
 222       exit (1);
 223     }
 224
 225   exit (0);
 226 }