Return to iconv_string.c CVS log

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

Annotation of embedaddon/libiconv/extras/iconv_string.c, revision 1.1.1.1

1.1       misho       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: }