unicode.C

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#include <errno.h>
#include <string.h>
#include <iconv.h>
#include <iostream>

#include <archon/util/exception.H>
#include <archon/util/unicode.H>

using namespace std;

namespace Archon
{
  namespace Utilities
  {
    namespace Unicode
    {
      string  encodeUtf8(ustring u)
      {
        string s;
        iconv_t cd = iconv_open("UTF-8", "UCS-4LE");
        if(cd==reinterpret_cast<iconv_t>(-1))
          ARCHON_THROW1(ResourceException,
                        string("Unexpected error from 'iconv_open': ") +
                        strerror(errno));
        char *inbuf = const_cast<char *>(reinterpret_cast<const char *>(u.data()));
        size_t inbytesleft = u.size() * 4;
        const size_t buffersize = 256;
        char buffer[buffersize];
        while(inbytesleft)
        {
          char *outbuf = buffer;
          size_t outbytesleft = buffersize;     
          const size_t n = iconv(cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
          if(outbytesleft < buffersize) s.append(buffer, buffersize - outbytesleft);
          if(n==static_cast<size_t>(-1) && errno != E2BIG)
          {
            s += "?";
            if(errno == EINVAL) break;
            if(errno == EILSEQ)
            {
              inbytesleft -= 4;
              inbuf += 4;
            }
            else
            {
              iconv_close(cd);
              ARCHON_THROW1(ResourceException,
                            string("Unexpected error from 'iconv': ") +
                            strerror(errno));
            }
          }
        }
        iconv_close(cd);
        return s;
      }

      ustring decodeUtf8(string s)
      {
        ustring u;
        iconv_t cd = iconv_open("UCS-4LE", "UTF-8");
        if(cd==reinterpret_cast<iconv_t>(-1))
          ARCHON_THROW1(ResourceException,
                        string("Unexpected error from 'iconv_open': ") +
                        strerror(errno));
        char *inbuf = const_cast<char *>(reinterpret_cast<const char *>(s.data()));
        size_t inbytesleft = s.size();
        const size_t buffersize = 256;
        char buffer[buffersize];
        while(inbytesleft)
        {
          char *outbuf = buffer;
          size_t outbytesleft = buffersize;     
          const size_t n = iconv(cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
          if(outbytesleft < buffersize)
            u.append(reinterpret_cast<const uchar *>(buffer), (buffersize - outbytesleft)/4);
          if(n==static_cast<size_t>(-1) && errno != E2BIG)
          {
            u.append(1, static_cast<uchar>('?'));
            if(errno == EINVAL) break;
            if(errno == EILSEQ)
            {
              --inbytesleft;
              ++inbuf;
            }
            else
            {
              iconv_close(cd);
              ARCHON_THROW1(ResourceException,
                            string("Unexpected error from 'iconv': ") +
                            strerror(errno));
            }
          }
        }
        iconv_close(cd);
        return u;
      }

      int decodeUtf8(const char *in, int inSize, uchar *out, int &outSize)
      {
        ustring u;
        iconv_t cd = iconv_open("UCS-4LE", "UTF-8");
        if(cd==reinterpret_cast<iconv_t>(-1))
          ARCHON_THROW1(ResourceException,
                        string("Unexpected error from 'iconv_open': ") +
                        strerror(errno));
        char *inbuf = const_cast<char *>(static_cast<const char *>(in));
        size_t inbytesleft = inSize;
        char *outbuf = reinterpret_cast<char *>(out);
        size_t outbytesleft = outSize*4;
        while(inbytesleft)
        {
          const size_t n = iconv(cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
          if(n==static_cast<size_t>(-1))
          {
            if(errno == E2BIG || errno == EINVAL) break;

            if(errno != EILSEQ)
            {
              iconv_close(cd);
              ARCHON_THROW1(ResourceException,
                            string("Unexpected error from 'iconv': ") +
                            strerror(errno));
            }

            if(!outbytesleft) break;

            *reinterpret_cast<uchar *>(outbuf) = '?';
            outbytesleft -= 4;
            outbuf += 4;
            --inbytesleft;
            ++inbuf;
          }
        }
        iconv_close(cd);
        outSize -= outbytesleft/4;
        return inSize-inbytesleft;
      }
    }
  }
}

---