Return to iconv_string.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libiconv / extras

libiconv

    1: /* Copyright (C) 1999-2001, 2003 Bruno Haible.
    2:    This file is not part of the GNU LIBICONV Library.
    3:    This file is put into the public domain.  */
    4: 
    5: #include "iconv_string.h"
    6: #include <iconv.h>
    7: #include <errno.h>
    8: #include <stdlib.h>
    9: #include <string.h>
   10: 
   11: #define tmpbufsize 4096
   12: 
   13: int iconv_string (const char* tocode, const char* fromcode,
   14:                   const char* start, const char* end,
   15:                   char** resultp, size_t* lengthp)
   16: {
   17:   iconv_t cd = iconv_open(tocode,fromcode);
   18:   size_t length;
   19:   char* result;
   20:   if (cd == (iconv_t)(-1)) {
   21:     if (errno != EINVAL)
   22:       return -1;
   23:     /* Unsupported fromcode or tocode. Check whether the caller requested
   24:        autodetection. */
   25:     if (!strcmp(fromcode,"autodetect_utf8")) {
   26:       int ret;
   27:       /* Try UTF-8 first. There are very few ISO-8859-1 inputs that would
   28:          be valid UTF-8, but many UTF-8 inputs are valid ISO-8859-1. */
   29:       ret = iconv_string(tocode,"UTF-8",start,end,resultp,lengthp);
   30:       if (!(ret < 0 && errno == EILSEQ))
   31:         return ret;
   32:       ret = iconv_string(tocode,"ISO-8859-1",start,end,resultp,lengthp);
   33:       return ret;
   34:     }
   35:     if (!strcmp(fromcode,"autodetect_jp")) {
   36:       int ret;
   37:       /* Try 7-bit encoding first. If the input contains bytes >= 0x80,
   38:          it will fail. */
   39:       ret = iconv_string(tocode,"ISO-2022-JP-2",start,end,resultp,lengthp);
   40:       if (!(ret < 0 && errno == EILSEQ))
   41:         return ret;
   42:       /* Try EUC-JP next. Short SHIFT_JIS inputs may come out wrong. This
   43:          is unavoidable. People will condemn SHIFT_JIS.
   44:          If we tried SHIFT_JIS first, then some short EUC-JP inputs would
   45:          come out wrong, and people would condemn EUC-JP and Unix, which
   46:          would not be good. */
   47:       ret = iconv_string(tocode,"EUC-JP",start,end,resultp,lengthp);
   48:       if (!(ret < 0 && errno == EILSEQ))
   49:         return ret;
   50:       /* Finally try SHIFT_JIS. */
   51:       ret = iconv_string(tocode,"SHIFT_JIS",start,end,resultp,lengthp);
   52:       return ret;
   53:     }
   54:     if (!strcmp(fromcode,"autodetect_kr")) {
   55:       int ret;
   56:       /* Try 7-bit encoding first. If the input contains bytes >= 0x80,
   57:          it will fail. */
   58:       ret = iconv_string(tocode,"ISO-2022-KR",start,end,resultp,lengthp);
   59:       if (!(ret < 0 && errno == EILSEQ))
   60:         return ret;
   61:       /* Finally try EUC-KR. */
   62:       ret = iconv_string(tocode,"EUC-KR",start,end,resultp,lengthp);
   63:       return ret;
   64:     }
   65:     errno = EINVAL;
   66:     return -1;
   67:   }
   68:   /* Determine the length we need. */
   69:   {
   70:     size_t count = 0;
   71:     char tmpbuf[tmpbufsize];
   72:     const char* inptr = start;
   73:     size_t insize = end-start;
   74:     while (insize > 0) {
   75:       char* outptr = tmpbuf;
   76:       size_t outsize = tmpbufsize;
   77:       size_t res = iconv(cd,&inptr,&insize,&outptr,&outsize);
   78:       if (res == (size_t)(-1) && errno != E2BIG) {
   79:         if (errno == EINVAL)
   80:           break;
   81:         else {
   82:           int saved_errno = errno;
   83:           iconv_close(cd);
   84:           errno = saved_errno;
   85:           return -1;
   86:         }
   87:       }
   88:       count += outptr-tmpbuf;
   89:     }
   90:     {
   91:       char* outptr = tmpbuf;
   92:       size_t outsize = tmpbufsize;
   93:       size_t res = iconv(cd,NULL,NULL,&outptr,&outsize);
   94:       if (res == (size_t)(-1)) {
   95:         int saved_errno = errno;
   96:         iconv_close(cd);
   97:         errno = saved_errno;
   98:         return -1;
   99:       }
  100:       count += outptr-tmpbuf;
  101:     }
  102:     length = count;
  103:   }
  104:   if (lengthp != NULL)
  105:     *lengthp = length;
  106:   if (resultp == NULL) {
  107:     iconv_close(cd);
  108:     return 0;
  109:   }
  110:   result = (*resultp == NULL ? malloc(length) : realloc(*resultp,length));
  111:   *resultp = result;
  112:   if (length == 0) {
  113:     iconv_close(cd);
  114:     return 0;
  115:   }
  116:   if (result == NULL) {
  117:     iconv_close(cd);
  118:     errno = ENOMEM;
  119:     return -1;
  120:   }
  121:   iconv(cd,NULL,NULL,NULL,NULL); /* return to the initial state */
  122:   /* Do the conversion for real. */
  123:   {
  124:     const char* inptr = start;
  125:     size_t insize = end-start;
  126:     char* outptr = result;
  127:     size_t outsize = length;
  128:     while (insize > 0) {
  129:       size_t res = iconv(cd,&inptr,&insize,&outptr,&outsize);
  130:       if (res == (size_t)(-1)) {
  131:         if (errno == EINVAL)
  132:           break;
  133:         else {
  134:           int saved_errno = errno;
  135:           iconv_close(cd);
  136:           errno = saved_errno;
  137:           return -1;
  138:         }
  139:       }
  140:     }
  141:     {
  142:       size_t res = iconv(cd,NULL,NULL,&outptr,&outsize);
  143:       if (res == (size_t)(-1)) {
  144:         int saved_errno = errno;
  145:         iconv_close(cd);
  146:         errno = saved_errno;
  147:         return -1;
  148:       }
  149:     }
  150:     if (outsize != 0) abort();
  151:   }
  152:   iconv_close(cd);
  153:   return 0;
  154: }