开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > xml/soap/webservice > 查看源码
SWIutfconversions.c
资源名称：openvxi-3.4.zip　[点击查看]
上传用户：xqtpzdz
上传日期：2022-05-21
资源大小：1764k
文件大小：28k
源码类别：

xml/soap/webservice

开发平台：

Visual C++

SWIutfconversions.c：源码内容
  1. /* SWIutfconversions, Unicode conversions */
  3. /****************License************************************************
  4.  * Vocalocity OpenVXI
  5.  * Copyright (C) 2004-2005 by Vocalocity, Inc. All Rights Reserved.
  6.  * This program is free software; you can redistribute it and/or
  7.  * modify it under the terms of the GNU General Public License
  8.  * as published by the Free Software Foundation; either version 2
  9.  * of the License, or (at your option) any later version.
  10.  *  
  11.  * This program 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
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; if not, write to the Free Software
  18.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19.  * Vocalocity, the Vocalocity logo, and VocalOS are trademarks or 
  20.  * registered trademarks of Vocalocity, Inc. 
  21.  * OpenVXI is a trademark of Scansoft, Inc. and used under license 
  22.  * by Vocalocity.
  23.  ***********************************************************************/
  25. /* -----1=0-------2=0-------3=0-------4=0-------5=0-------6=0-------7=0-------8
  26.  */
  28. #include <stdio.h>
  29. #include <string.h>
  30. #include <SWIutfconversions.h>
  32. #if 0
  33. #include "Encoding.h"
  34. #include <cstring>
  35. #include <cwchar>
  36. #include <vector>
  37. #include <algorithm>
  39. bool initialized = false;
  42. // ---------------------------------------------------------------------------
  43. // Define a registry of decoder functions.
  44. // ---------------------------------------------------------------------------
  46. typedef bool (*DECODERFUNCTION)(const char *,
  47.                                 std::basic_string<wchar_t> &);
  49. class EncoderEntry {
  50. public:
  51.   const char * name;
  52.   DECODERFUNCTION function;
  54.   EncoderEntry(const char * x, DECODERFUNCTION y)
  55.     : name(x), function(y) { }
  57.   EncoderEntry(const EncoderEntry & x) : name(x.name), function(x.function) { }
  59.   EncoderEntry & operator=(const EncoderEntry & x)
  60.   { if (this != &x) { name = x.name;  function = x.function; }
  61.     return *this; }
  62. };
  64. bool operator<(const EncoderEntry & x, const EncoderEntry & y)
  65. { return strcmp(x.name, y.name) < 0; }
  67. // ---------------------------------------------------------------------------
  69. typedef std::vector<EncoderEntry> DECODER_REGISTRY;
  70. DECODER_REGISTRY decoderRegistry;
  72. void InitializeDecoder()
  73. {
  74.   if(initialized)
  75.     return;
  76.   decoderRegistry.push_back(EncoderEntry("utf-8",       DecodeUTF8));
  77.   decoderRegistry.push_back(EncoderEntry("utf8",        DecodeUTF8));
  79.   decoderRegistry.push_back(EncoderEntry("us-ascii",    DecodeASCII));
  80.   decoderRegistry.push_back(EncoderEntry("us_ascii",    DecodeASCII));
  81.   decoderRegistry.push_back(EncoderEntry("usascii",     DecodeASCII));
  82.   decoderRegistry.push_back(EncoderEntry("ascii",       DecodeASCII));
  84.   decoderRegistry.push_back(EncoderEntry("iso8859-1",   DecodeISO8859_1));
  85.   decoderRegistry.push_back(EncoderEntry("iso-8859-1",  DecodeISO8859_1));
  86.   decoderRegistry.push_back(EncoderEntry("iso_8859-1",  DecodeISO8859_1));
  87.   decoderRegistry.push_back(EncoderEntry("latin1",      DecodeISO8859_1));
  88.   decoderRegistry.push_back(EncoderEntry("latin-1",     DecodeISO8859_1));
  89.   decoderRegistry.push_back(EncoderEntry("latin_1",     DecodeISO8859_1));
  90.   decoderRegistry.push_back(EncoderEntry("ibm-819",     DecodeISO8859_1));
  91.   decoderRegistry.push_back(EncoderEntry("ibm819",      DecodeISO8859_1));
  93.   decoderRegistry.push_back(EncoderEntry("iso8859-2",   DecodeISO8859_2));
  94.   decoderRegistry.push_back(EncoderEntry("iso-8859-2",  DecodeISO8859_2));
  95.   decoderRegistry.push_back(EncoderEntry("iso_8859-2",  DecodeISO8859_2));
  96.   decoderRegistry.push_back(EncoderEntry("latin2",      DecodeISO8859_2));
  97.   decoderRegistry.push_back(EncoderEntry("latin-2",     DecodeISO8859_2));
  98.   decoderRegistry.push_back(EncoderEntry("latin_2",     DecodeISO8859_2));
  100.   decoderRegistry.push_back(EncoderEntry("iso8859-3",   DecodeISO8859_3));
  101.   decoderRegistry.push_back(EncoderEntry("iso-8859-3",  DecodeISO8859_3));
  102.   decoderRegistry.push_back(EncoderEntry("iso_8859-3",  DecodeISO8859_3));
  103.   decoderRegistry.push_back(EncoderEntry("latin3",      DecodeISO8859_3));
  104.   decoderRegistry.push_back(EncoderEntry("latin-3",     DecodeISO8859_3));
  105.   decoderRegistry.push_back(EncoderEntry("latin_3",     DecodeISO8859_3));
  107.   decoderRegistry.push_back(EncoderEntry("iso8859-4",   DecodeISO8859_4));
  108.   decoderRegistry.push_back(EncoderEntry("iso-8859-4",  DecodeISO8859_4));
  109.   decoderRegistry.push_back(EncoderEntry("iso_8859-4",  DecodeISO8859_4));
  110.   decoderRegistry.push_back(EncoderEntry("latin4",      DecodeISO8859_4));
  111.   decoderRegistry.push_back(EncoderEntry("latin-4",     DecodeISO8859_4));
  112.   decoderRegistry.push_back(EncoderEntry("latin_4",     DecodeISO8859_4));
  114.   decoderRegistry.push_back(EncoderEntry("iso8859-15",  DecodeISO8859_15));
  115.   decoderRegistry.push_back(EncoderEntry("iso-8859-15", DecodeISO8859_15));
  116.   decoderRegistry.push_back(EncoderEntry("iso_8859-15", DecodeISO8859_15));
  117.   decoderRegistry.push_back(EncoderEntry("latin9",      DecodeISO8859_15));
  118.   decoderRegistry.push_back(EncoderEntry("latin-9",     DecodeISO8859_15));
  119.   decoderRegistry.push_back(EncoderEntry("latin_9",     DecodeISO8859_15));
  121.   std::sort(decoderRegistry.begin(), decoderRegistry.end());
  123.   initialized = true;
  124. }
  126. static bool DoInitialization()
  127. {
  128.   if(initialized)
  129.     return true;
  130.   InitializeDecoder();
  131.   return true;
  132. }
  133. bool do_initialization = DoInitialization();
  136. int DecodeString(const char * encodingName,
  137.                  const char * inputString,
  138.                  std::basic_string<wchar_t> & outputString)
  139. {
  140.   if (!initialized || encodingName == NULL || inputString == NULL)
  141.     return -1;
  143.   // (1) Convert string to lowercase.
  144.   std::basic_string<char> encoding(encodingName);
  145.   for (unsigned int i = 0; i < encoding.length(); ++i)
  146.     if (encoding[i] < 0x5B && encoding[i] > 0x40)
  147.       encoding[i] += 0x20;
  149.   DECODER_REGISTRY::iterator j 
  150.     = std::lower_bound(decoderRegistry.begin(), decoderRegistry.end(),
  151.                        EncoderEntry(encoding.c_str(), NULL));
  153.   if (j == decoderRegistry.end() || encoding != (*j).name) return -1;
  155.   if ((*j).function(inputString, outputString)) return 0;
  156.   return 1;
  157. }
  160. // ---------------------------------------------------------------------------
  161. // Now we define the 'simple' decoder functions
  162. // ---------------------------------------------------------------------------
  164. bool DecodeASCII(const char * in, std::basic_string<wchar_t> & out)
  165. {
  166.   out.erase();
  168.   while (*in != '') {
  169.     char c = *in;
  170.     if (c > 0x7f || c < 0) return false;
  171.     out += wchar_t(c);
  172.     ++in;
  173.   }
  175.   return true;
  176. }
  179. bool DecodeISO8859_1(const char * in, std::basic_string<wchar_t> & out)
  180. {
  181.   out.erase();
  183.   while (*in != '') {
  184.     out += wchar_t(*in);
  185.     ++in;
  186.   } 
  187.   return true;
  188. }
  191. bool DecodeISO8859_2(const char * in, std::basic_string<wchar_t> & out)
  192. {
  193.   out.erase();
  194.   wchar_t w;
  196.   while (*in != '') {
  197.     switch (*in) {
  198.     case 0xA1:  w = 0x0104;  break; // LATIN CAPITAL LETTER A WITH OGONEK
  199.     case 0xA2:  w = 0x02D8;  break; // BREVE
  200.     case 0xA3:  w = 0x0141;  break; // LATIN CAPITAL LETTER L WITH STROKE
  201.     case 0xA5:  w = 0x013D;  break; // LATIN CAPITAL LETTER L WITH CARON
  202.     case 0xA6:  w = 0x015A;  break; // LATIN CAPITAL LETTER S WITH ACUTE
  203.     case 0xA9:  w = 0x0160;  break; // LATIN CAPITAL LETTER S WITH CARON
  204.     case 0xAA:  w = 0x015E;  break; // LATIN CAPITAL LETTER S WITH CEDILLA
  205.     case 0xAB:  w = 0x0164;  break; // LATIN CAPITAL LETTER T WITH CARON
  206.     case 0xAC:  w = 0x0179;  break; // LATIN CAPITAL LETTER Z WITH ACUTE
  207.     case 0xAE:  w = 0x017D;  break; // LATIN CAPITAL LETTER Z WITH CARON
  208.     case 0xAF:  w = 0x017B;  break; // LATIN CAPITAL LETTER Z WITH DOT ABOVE
  209.     case 0xB1:  w = 0x0105;  break; // LATIN SMALL LETTER A WITH OGONEK
  210.     case 0xB2:  w = 0x02DB;  break; // OGONEK
  211.     case 0xB3:  w = 0x0142;  break; // LATIN SMALL LETTER L WITH STROKE
  212.     case 0xB5:  w = 0x013E;  break; // LATIN SMALL LETTER L WITH CARON
  213.     case 0xB6:  w = 0x015B;  break; // LATIN SMALL LETTER S WITH ACUTE
  214.     case 0xB7:  w = 0x02C7;  break; // CARON
  215.     case 0xB9:  w = 0x0161;  break; // LATIN SMALL LETTER S WITH CARON
  216.     case 0xBA:  w = 0x015F;  break; // LATIN SMALL LETTER S WITH CEDILLA
  217.     case 0xBB:  w = 0x0165;  break; // LATIN SMALL LETTER T WITH CARON
  218.     case 0xBC:  w = 0x017A;  break; // LATIN SMALL LETTER Z WITH ACUTE
  219.     case 0xBD:  w = 0x02DD;  break; // DOUBLE ACUTE ACCENT
  220.     case 0xBE:  w = 0x017E;  break; // LATIN SMALL LETTER Z WITH CARON
  221.     case 0xBF:  w = 0x017C;  break; // LATIN SMALL LETTER Z WITH DOT ABOVE
  222.     case 0xC0:  w = 0x0154;  break; // LATIN CAPITAL LETTER R WITH ACUTE
  223.     case 0xC3:  w = 0x0102;  break; // LATIN CAPITAL LETTER A WITH BREVE
  224.     case 0xC5:  w = 0x0139;  break; // LATIN CAPITAL LETTER L WITH ACUTE
  225.     case 0xC6:  w = 0x0106;  break; // LATIN CAPITAL LETTER C WITH ACUTE
  226.     case 0xC8:  w = 0x010C;  break; // LATIN CAPITAL LETTER C WITH CARON
  227.     case 0xCA:  w = 0x0118;  break; // LATIN CAPITAL LETTER E WITH OGONEK
  228.     case 0xCC:  w = 0x011A;  break; // LATIN CAPITAL LETTER E WITH CARON
  229.     case 0xCF:  w = 0x010E;  break; // LATIN CAPITAL LETTER D WITH CARON
  230.     case 0xD0:  w = 0x0110;  break; // LATIN CAPITAL LETTER D WITH STROKE
  231.     case 0xD1:  w = 0x0143;  break; // LATIN CAPITAL LETTER N WITH ACUTE
  232.     case 0xD2:  w = 0x0147;  break; // LATIN CAPITAL LETTER N WITH CARON
  233.     case 0xD5:  w = 0x0150;  break; // LATIN CAPITAL LETTER O WITH DOUBLE ACUTE
  234.     case 0xD8:  w = 0x0158;  break; // LATIN CAPITAL LETTER R WITH CARON
  235.     case 0xD9:  w = 0x016E;  break; // LATIN CAPITAL LETTER U WITH RING ABOVE
  236.     case 0xDB:  w = 0x0170;  break; // LATIN CAPITAL LETTER U WITH DOUBLE ACUTE
  237.     case 0xDE:  w = 0x0162;  break; // LATIN CAPITAL LETTER T WITH CEDILLA
  238.     case 0xE0:  w = 0x0155;  break; // LATIN SMALL LETTER R WITH ACUTE
  239.     case 0xE3:  w = 0x0103;  break; // LATIN SMALL LETTER A WITH BREVE
  240.     case 0xE5:  w = 0x013A;  break; // LATIN SMALL LETTER L WITH ACUTE
  241.     case 0xE6:  w = 0x0107;  break; // LATIN SMALL LETTER C WITH ACUTE
  242.     case 0xE8:  w = 0x010D;  break; // LATIN SMALL LETTER C WITH CARON
  243.     case 0xEA:  w = 0x0119;  break; // LATIN SMALL LETTER E WITH OGONEK
  244.     case 0xEC:  w = 0x011B;  break; // LATIN SMALL LETTER E WITH CARON
  245.     case 0xEF:  w = 0x010F;  break; // LATIN SMALL LETTER D WITH CARON
  246.     case 0xF0:  w = 0x0111;  break; // LATIN SMALL LETTER D WITH STROKE
  247.     case 0xF1:  w = 0x0144;  break; // LATIN SMALL LETTER N WITH ACUTE
  248.     case 0xF2:  w = 0x0148;  break; // LATIN SMALL LETTER N WITH CARON
  249.     case 0xF5:  w = 0x0151;  break; // LATIN SMALL LETTER O WITH DOUBLE ACUTE
  250.     case 0xF8:  w = 0x0159;  break; // LATIN SMALL LETTER R WITH CARON
  251.     case 0xF9:  w = 0x016F;  break; // LATIN SMALL LETTER U WITH RING ABOVE
  252.     case 0xFB:  w = 0x0171;  break; // LATIN SMALL LETTER U WITH DOUBLE ACUTE
  253.     case 0xFE:  w = 0x0163;  break; // LATIN SMALL LETTER T WITH CEDILLA
  254.     case 0xFF:  w = 0x02D9;  break; // DOT ABOVE
  255.     default:
  256.       w = wchar_t(*in);
  257.       break;
  258.     }
  259.     out += w;
  260.     ++in;
  261.   }
  263.   return true;
  264. }
  267. bool DecodeISO8859_3(const char * in, std::basic_string<wchar_t> & out)
  268. {
  269.   out.erase();
  270.   wchar_t w;
  272.   while (*in != '') {
  273.     switch (*in) {
  274.     case 0xA1:  w = 0x0126;  break; // LATIN CAPITAL LETTER H WITH STROKE
  275.     case 0xA2:  w = 0x02D8;  break; // BREVE
  276.     case 0xA6:  w = 0x0124;  break; // LATIN CAPITAL LETTER H WITH CIRCUMFLEX
  277.     case 0xA9:  w = 0x0130;  break; // LATIN CAPITAL LETTER I WITH DOT ABOVE
  278.     case 0xAA:  w = 0x015E;  break; // LATIN CAPITAL LETTER S WITH CEDILLA
  279.     case 0xAB:  w = 0x011E;  break; // LATIN CAPITAL LETTER G WITH BREVE
  280.     case 0xAC:  w = 0x0134;  break; // LATIN CAPITAL LETTER J WITH CIRCUMFLEX
  281.     case 0xAF:  w = 0x017B;  break; // LATIN CAPITAL LETTER Z WITH DOT ABOVE
  282.     case 0xB1:  w = 0x0127;  break; // LATIN SMALL LETTER H WITH STROKE
  283.     case 0xB6:  w = 0x0125;  break; // LATIN SMALL LETTER H WITH CIRCUMFLEX
  284.     case 0xB9:  w = 0x0131;  break; // LATIN SMALL LETTER DOTLESS I
  285.     case 0xBA:  w = 0x015F;  break; // LATIN SMALL LETTER S WITH CEDILLA
  286.     case 0xBB:  w = 0x011F;  break; // LATIN SMALL LETTER G WITH BREVE
  287.     case 0xBC:  w = 0x0135;  break; // LATIN SMALL LETTER J WITH CIRCUMFLEX
  288.     case 0xBF:  w = 0x017C;  break; // LATIN SMALL LETTER Z WITH DOT ABOVE
  289.     case 0xC5:  w = 0x010A;  break; // LATIN CAPITAL LETTER C WITH DOT ABOVE
  290.     case 0xC6:  w = 0x0108;  break; // LATIN CAPITAL LETTER C WITH CIRCUMFLEX
  291.     case 0xD5:  w = 0x0120;  break; // LATIN CAPITAL LETTER G WITH DOT ABOVE
  292.     case 0xD8:  w = 0x011C;  break; // LATIN CAPITAL LETTER G WITH CIRCUMFLEX
  293.     case 0xDD:  w = 0x016C;  break; // LATIN CAPITAL LETTER U WITH BREVE
  294.     case 0xDE:  w = 0x015C;  break; // LATIN CAPITAL LETTER S WITH CIRCUMFLEX
  295.     case 0xE5:  w = 0x010B;  break; // LATIN SMALL LETTER C WITH DOT ABOVE
  296.     case 0xE6:  w = 0x0109;  break; // LATIN SMALL LETTER C WITH CIRCUMFLEX
  297.     case 0xF5:  w = 0x0121;  break; // LATIN SMALL LETTER G WITH DOT ABOVE
  298.     case 0xF8:  w = 0x011D;  break; // LATIN SMALL LETTER G WITH CIRCUMFLEX
  299.     case 0xFD:  w = 0x016D;  break; // LATIN SMALL LETTER U WITH BREVE
  300.     case 0xFE:  w = 0x015D;  break; // LATIN SMALL LETTER S WITH CIRCUMFLEX
  301.     case 0xFF:  w = 0x02D9;  break; // DOT ABOVE
  302.     default:
  303.       w = wchar_t(*in);
  304.       break;
  305.     }
  306.     out += w;
  307.     ++in;
  308.   }
  310.   return true;
  311. }
  314. bool DecodeISO8859_4(const char * in, std::basic_string<wchar_t> & out)
  315. {
  316.   out.erase();
  317.   wchar_t w;
  319.   while (*in != '') {
  320.     switch (*in) {
  321.     case 0xA1:  w = 0x0104;  break; // LATIN CAPITAL LETTER A WITH OGONEK
  322.     case 0xA2:  w = 0x0138;  break; // LATIN SMALL LETTER KRA
  323.     case 0xA3:  w = 0x0156;  break; // LATIN CAPITAL LETTER R WITH CEDILLA
  324.     case 0xA5:  w = 0x0128;  break; // LATIN CAPITAL LETTER I WITH TILDE
  325.     case 0xA6:  w = 0x013B;  break; // LATIN CAPITAL LETTER L WITH CEDILLA
  326.     case 0xA9:  w = 0x0160;  break; // LATIN CAPITAL LETTER S WITH CARON
  327.     case 0xAA:  w = 0x0112;  break; // LATIN CAPITAL LETTER E WITH MACRON
  328.     case 0xAB:  w = 0x0122;  break; // LATIN CAPITAL LETTER G WITH CEDILLA
  329.     case 0xAC:  w = 0x0166;  break; // LATIN CAPITAL LETTER T WITH STROKE
  330.     case 0xAE:  w = 0x017D;  break; // LATIN CAPITAL LETTER Z WITH CARON
  331.     case 0xB1:  w = 0x0105;  break; // LATIN SMALL LETTER A WITH OGONEK
  332.     case 0xB2:  w = 0x02DB;  break; // OGONEK
  333.     case 0xB3:  w = 0x0157;  break; // LATIN SMALL LETTER R WITH CEDILLA
  334.     case 0xB5:  w = 0x0129;  break; // LATIN SMALL LETTER I WITH TILDE
  335.     case 0xB6:  w = 0x013C;  break; // LATIN SMALL LETTER L WITH CEDILLA
  336.     case 0xB7:  w = 0x02C7;  break; // CARON
  337.     case 0xB9:  w = 0x0161;  break; // LATIN SMALL LETTER S WITH CARON
  338.     case 0xBA:  w = 0x0113;  break; // LATIN SMALL LETTER E WITH MACRON
  339.     case 0xBB:  w = 0x0123;  break; // LATIN SMALL LETTER G WITH CEDILLA
  340.     case 0xBC:  w = 0x0167;  break; // LATIN SMALL LETTER T WITH STROKE
  341.     case 0xBD:  w = 0x014A;  break; // LATIN CAPITAL LETTER ENG
  342.     case 0xBE:  w = 0x017E;  break; // LATIN SMALL LETTER Z WITH CARON
  343.     case 0xBF:  w = 0x014B;  break; // LATIN SMALL LETTER ENG
  344.     case 0xC0:  w = 0x0100;  break; // LATIN CAPITAL LETTER A WITH MACRON
  345.     case 0xC7:  w = 0x012E;  break; // LATIN CAPITAL LETTER I WITH OGONEK
  346.     case 0xC8:  w = 0x010C;  break; // LATIN CAPITAL LETTER C WITH CARON
  347.     case 0xCA:  w = 0x0118;  break; // LATIN CAPITAL LETTER E WITH OGONEK
  348.     case 0xCC:  w = 0x0116;  break; // LATIN CAPITAL LETTER E WITH DOT ABOVE
  349.     case 0xCF:  w = 0x012A;  break; // LATIN CAPITAL LETTER I WITH MACRON
  350.     case 0xD0:  w = 0x0110;  break; // LATIN CAPITAL LETTER D WITH STROKE
  351.     case 0xD1:  w = 0x0145;  break; // LATIN CAPITAL LETTER N WITH CEDILLA
  352.     case 0xD2:  w = 0x014C;  break; // LATIN CAPITAL LETTER O WITH MACRON
  353.     case 0xD3:  w = 0x0136;  break; // LATIN CAPITAL LETTER K WITH CEDILLA
  354.     case 0xD9:  w = 0x0172;  break; // LATIN CAPITAL LETTER U WITH OGONEK
  355.     case 0xDD:  w = 0x0168;  break; // LATIN CAPITAL LETTER U WITH TILDE
  356.     case 0xDE:  w = 0x016A;  break; // LATIN CAPITAL LETTER U WITH MACRON
  357.     case 0xE0:  w = 0x0101;  break; // LATIN SMALL LETTER A WITH MACRON
  358.     case 0xE7:  w = 0x012F;  break; // LATIN SMALL LETTER I WITH OGONEK
  359.     case 0xE8:  w = 0x010D;  break; // LATIN SMALL LETTER C WITH CARON
  360.     case 0xEA:  w = 0x0119;  break; // LATIN SMALL LETTER E WITH OGONEK
  361.     case 0xEC:  w = 0x0117;  break; // LATIN SMALL LETTER E WITH DOT ABOVE
  362.     case 0xEF:  w = 0x012B;  break; // LATIN SMALL LETTER I WITH MACRON
  363.     case 0xF0:  w = 0x0111;  break; // LATIN SMALL LETTER D WITH STROKE
  364.     case 0xF1:  w = 0x0146;  break; // LATIN SMALL LETTER N WITH CEDILLA
  365.     case 0xF2:  w = 0x014D;  break; // LATIN SMALL LETTER O WITH MACRON
  366.     case 0xF3:  w = 0x0137;  break; // LATIN SMALL LETTER K WITH CEDILLA
  367.     case 0xF9:  w = 0x0173;  break; // LATIN SMALL LETTER U WITH OGONEK
  368.     case 0xFD:  w = 0x0169;  break; // LATIN SMALL LETTER U WITH TILDE
  369.     case 0xFE:  w = 0x016B;  break; // LATIN SMALL LETTER U WITH MACRON
  370.     case 0xFF:  w = 0x02D9;  break; // DOT ABOVE
  371.     default:
  372.       w = wchar_t(*in);
  373.       break;
  374.     }
  375.     out += w;
  376.     ++in;
  377.   }
  379.   return true;
  380. }
  383. bool DecodeISO8859_15(const char * in, std::basic_string<wchar_t> & out)
  384. {
  385.   out.erase();
  387.   wchar_t w;
  389.   while (*in != '') {
  390.     switch (*in) {
  391.     case 0xA4:  w = 0x20AC;  break; // EURO SIGN
  392.     case 0xA6:  w = 0x0160;  break; // LATIN CAPITAL LETTER S WITH CARON
  393.     case 0xA8:  w = 0x0161;  break; // LATIN SMALL LETTER S WITH CARON
  394.     case 0xB4:  w = 0x017D;  break; // LATIN CAPITAL LETTER Z WITH CARON
  395.     case 0xB8:  w = 0x017E;  break; // LATIN SMALL LETTER Z WITH CARON
  396.     case 0xBC:  w = 0x0152;  break; // LATIN CAPITAL LIGATURE OE
  397.     case 0xBD:  w = 0x0153;  break; // LATIN SMALL LIGATURE OE
  398.     case 0xBE:  w = 0x0178;  break; // LATIN CAPITAL LETTER Y WITH DIAERESIS
  399.     default:
  400.       w = wchar_t(*in);
  401.       break;
  402.     }
  403.     out += w;
  404.     ++in;
  405.   }
  407.   return true;
  408. }
  409. #endif
  411. // ---------------------------------------------------------------------------
  412. // Jerry Carter writes:
  413. //
  414. // The UTF-8 encoding / decoding routines were modified from the Apache Xerces
  415. // project.  The original translated from UTF-8 to UTF-16.  In this version, I
  416. // have removed support for surrogate characters.  This removes the difference
  417. // between platforms which treat wchar_t as UTF-16 (Windows) and those which
  418. // use UTF-32 (Linux, MacOS, etc.).
  419. //
  420. // The Apache license appears below (as required).
  422. /*
  423.  * The Apache Software License, Version 1.1
  424.  * 
  425.  * Copyright (c) 1999-2000 The Apache Software Foundation.  All rights
  426.  * reserved.
  427.  * 
  428.  * Redistribution and use in source and binary forms, with or without
  429.  * modification, are permitted provided that the following conditions
  430.  * are met:
  431.  * 
  432.  * 1. Redistributions of source code must retain the above copyright
  433.  *    notice, this list of conditions and the following disclaimer. 
  434.  * 
  435.  * 2. Redistributions in binary form must reproduce the above copyright
  436.  *    notice, this list of conditions and the following disclaimer in
  437.  *    the documentation and/or other materials provided with the
  438.  *    distribution.
  439.  * 
  440.  * 3. The end-user documentation included with the redistribution,
  441.  *    if any, must include the following acknowledgment:  
  442.  *       "This product includes software developed by the
  443.  *        Apache Software Foundation (http://www.apache.org/)."
  444.  *    Alternately, this acknowledgment may appear in the software itself,
  445.  *    if and wherever such third-party acknowledgments normally appear.
  446.  * 
  447.  * 4. The names "Xerces" and "Apache Software Foundation" must
  448.  *    not be used to endorse or promote products derived from this
  449.  *    software without prior written permission. For written 
  450.  *    permission, please contact apache@apache.org.
  451.  * 
  452.  * 5. Products derived from this software may not be called "Apache",
  453.  *    nor may "Apache" appear in their name, without prior written
  454.  *    permission of the Apache Software Foundation.
  455.  * 
  456.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  457.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  458.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  459.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  460.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  461.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  462.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  463.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  464.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  465.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  466.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  467.  * SUCH DAMAGE.
  468.  * ====================================================================
  469.  * 
  470.  * This software consists of voluntary contributions made by many
  471.  * individuals on behalf of the Apache Software Foundation, and was
  472.  * originally based on software copyright (c) 1999, International
  473.  * Business Machines, Inc., http://www.ibm.com .  For more information
  474.  * on the Apache Software Foundation, please see
  475.  * <http://www.apache.org/>.
  476.  */
  478. //  gUTFBytes
  479. //      A list of counts of trailing bytes for each initial byte in the input.
  480. //
  481. //  gUTFOffsets
  482. //      A list of values to offset each result char type, according to how
  483. //      many source bytes when into making it.
  484. //
  485. //  gFirstByteMark
  486. //      A list of values to mask onto the first byte of an encoded sequence,
  487. //      indexed by the number of bytes used to create the sequence.
  489. static const char gUTFBytes[256] =
  490. {
  491.         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  492.     ,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  493.     ,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  494.     ,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  495.     ,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  496.     ,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  497.     ,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  498.     ,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  499.     ,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  500.     ,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  501.     ,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  502.     ,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  503.     ,   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
  504.     ,   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
  505.     ,   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
  506.     ,   3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5
  507. };
  509. static const unsigned long gUTFOffsets[6] =
  510. {  0, 0x3080, 0xE2080, 0x3C82080, 0xFA082080, 0x82082080 };
  512. static const unsigned char gFirstByteMark[7] =
  513. {  0x00, 0x00, 0xC0, 0xE0,
  514.    0xF0, 0xF8, 0xFC };
  517. int SWIutf8towcslen(const unsigned char* src)
  518. {
  519.   int len = 0;
  521.   while (*src != '') {
  522.     unsigned int trailingBytes;
  524.     // Get the next leading byte out
  525.     const unsigned char firstByte = (unsigned char) *src;
  527.     // See how many trailing src bytes this sequence is going to require
  528.     trailingBytes = gUTFBytes[firstByte];
  530.     src += trailingBytes + 1;
  531.     len++;
  532.   }
  533.   return len;
  534. }
  537. SWIcharResult SWIutf8towcs( const unsigned char *src, wchar_t *dst, int maxdstlen )
  538. {
  539.   // Get pointers to our start and end points of the input buffer
  540.   const unsigned char* srcPtr = src;
  541.   const unsigned char* srcEnd = src + strlen((const char *)src);
  542.   //wchar_t *dstSave = dst;
  543.   wchar_t *dstEnd = dst+maxdstlen;  /* leave room for null */
  545.   //  We now loop until we run out of input data.
  546.   while (srcPtr < srcEnd) {
  547.     unsigned int trailingBytes;
  548.     unsigned long tmpVal = 0;
  550.     // Get the next leading byte out
  551.     const unsigned char firstByte = (unsigned char) *srcPtr;
  553.     // Special-case ASCII, which is a leading byte value of <= 127
  554.     if (firstByte <= 127) {
  555.       *dst++ = (wchar_t) firstByte;
  556.       srcPtr++;
  557.       continue;
  558.     }
  560.     // See how many trailing src bytes this sequence is going to require
  561.     trailingBytes = gUTFBytes[firstByte];
  562.     
  563.     //  If there are not enough source bytes to do this one, then we
  564.     //  are done. Note that we done >= here because we are implicitly
  565.     //  counting the 1 byte we get no matter what.
  566.     if (srcPtr + trailingBytes >= srcEnd)
  567.       return SWIchar_FAIL;  // ??
  569.     // Looks ok, so lets build up the value
  570.     switch (trailingBytes) {
  571.     case 5: tmpVal += *srcPtr++; tmpVal <<= 6;
  572.     case 4: tmpVal += *srcPtr++; tmpVal <<= 6;
  573.     case 3: tmpVal += *srcPtr++; tmpVal <<= 6;
  574.     case 2: tmpVal += *srcPtr++; tmpVal <<= 6;
  575.     case 1: tmpVal += *srcPtr++; tmpVal <<= 6;
  576.     case 0: tmpVal += *srcPtr++;
  577.       break;
  578.     default:
  579.       return SWIchar_ERROR;
  580.     }
  581.     tmpVal -= gUTFOffsets[trailingBytes];
  583.     // If surrogate pairs would be required for 16-bit characters, fail.
  584.     if (tmpVal & 0xFFFF0000)
  585.       return SWIchar_FAIL;
  587.     if ( dst >= dstEnd ) {
  588.       return SWIchar_BUFFER_OVERFLOW;
  589.     }
  591.     *dst++ = (wchar_t)tmpVal;
  592.   }
  594.   *dst = L'';
  595.   
  596.  // return dst-dstSave;
  598.   return SWIchar_SUCCESS;   // check this (CARO)
  599. }
  601. int SWIwcstoutf8len(const wchar_t* src)
  602. {
  603.   int len = 0;
  605.   while (*src != 0) {
  606.     unsigned int encodedBytes;
  607.     wchar_t curVal = (*src++) & 0x0000FFFF;
  609.     // Watchout for surrogates.
  610.     if ((curVal >= 0xD800 && curVal <= 0xDBFF) || curVal == 0xFFFE ||
  611. curVal == 0xFFFF)
  612.       return -2;
  614.     // Figure out how many bytes we need
  615.     if (curVal < 0x80)                encodedBytes = 1;
  616.     else if (curVal < 0x800)          encodedBytes = 2;
  617.     else if (curVal < 0x10000)        encodedBytes = 3;
  618.     else if (curVal < 0x200000)       encodedBytes = 4;
  619.     else if (curVal < 0x4000000)      encodedBytes = 5;
  620.     else if (curVal <= 0x7FFFFFFF)    encodedBytes = 6;
  621.     else {
  622.       // THIS SHOULD NOT HAPPEN!
  623.       return -2;
  624.     }
  626.     //  And spit out the bytes. We spit them out in reverse order
  627.     //  here, so bump up the output pointer and work down as we go.
  628.     len += encodedBytes;
  629.   }
  631.   return len;
  632. }
  635. SWIcharResult SWIwcstoutf8(const wchar_t *src, unsigned char *dst, int maxdstlen)
  636. {
  637.   //  Get pointers to our start and end points of the input buffer.
  638.   const wchar_t* srcPtr = src;
  639.   const wchar_t* srcEnd = srcPtr + wcslen(src);
  640.   //unsigned char *dstSave = dst;
  641.   unsigned char *dstEnd = dst+maxdstlen;
  643.   while (srcPtr < srcEnd) {
  644.     unsigned int encodedBytes;
  645.     wchar_t curVal = (*srcPtr++) & 0x0000FFFF;
  647.     // Watchout for surrogates.
  648.     if ( ((curVal >= 0xD800) && (curVal <= 0xDFFF)) ||
  649.          ((curVal == 0xFFFE) || curVal == 0xFFFF) )
  650.       return SWIchar_FAIL;
  652.     // Figure out how many bytes we need
  653.     if (curVal < 0x80)                encodedBytes = 1;
  654.     else if (curVal < 0x800)          encodedBytes = 2;
  655.     else if (curVal < 0x10000)        encodedBytes = 3;
  656.     else if (curVal < 0x200000)       encodedBytes = 4;
  657.     else if (curVal < 0x4000000)      encodedBytes = 5;
  658.     else if (curVal <= 0x7FFFFFFF)    encodedBytes = 6;
  659.     else {
  660.       // THIS SHOULD NOT HAPPEN!
  661.       return SWIchar_ERROR;
  662.     }
  664.     //  And spit out the bytes. We spit them out in reverse order
  665.     //  here, so bump up the output pointer and work down as we go.
  666.     dst += encodedBytes;
  668.     if ( dst > dstEnd ) {
  669.       return SWIchar_BUFFER_OVERFLOW;
  670.     }
  672.     switch(encodedBytes) {
  673.     case 6 : *--dst = (unsigned char) ((curVal | 0x80) & 0xBF);
  674.       curVal >>= 6;
  675.     case 5 : *--dst = (unsigned char)((curVal | 0x80) & 0xBF);
  676.       curVal >>= 6;
  677.     case 4 : *--dst = (unsigned char)((curVal | 0x80) & 0xBF);
  678.       curVal >>= 6;
  679.     case 3 : *--dst = (unsigned char)((curVal | 0x80) & 0xBF);
  680.       curVal >>= 6;
  681.     case 2 : *--dst = (unsigned char)((curVal | 0x80) & 0xBF);
  682.       curVal >>= 6;
  683.     case 1 : *--dst = (unsigned char)(curVal | gFirstByteMark[encodedBytes]);
  684.     }
  686.     dst += encodedBytes;
  687.   }
  688.   *dst = '';
  690.   // return dst-dstSave
  692.   return SWIchar_SUCCESS; // check this (CARO)
  693. }