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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多国语言处理 > 词法分析 > 查看源码
IconvFBSDTransService.cpp
资源名称：xerces-c-src_2_3_0.zip　[点击查看]
上传用户：zhuqijet
上传日期：2013-06-25
资源大小：10074k
文件大小：56k
源码类别：

词法分析

开发平台：

Visual C++

IconvFBSDTransService.cpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 2001 The Apache Software Foundation.  All rights
  5.  * reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  *
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  *
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution.
  18.  *
  19.  * 3. The end-user documentation included with the redistribution,
  20.  *    if any, must include the following acknowledgment:
  21.  *       "This product includes software developed by the
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowledgment may appear in the software itself,
  24.  *    if and wherever such third-party acknowledgments normally appear.
  25.  *
  26.  * 4. The names "Xerces" and "Apache Software Foundation" must
  27.  *    not be used to endorse or promote products derived from this
  28.  *    software without prior written permission. For written
  29.  *    permission, please contact apache@apache.org.
  30.  *
  31.  * 5. Products derived from this software may not be called "Apache",
  32.  *    nor may "Apache" appear in their name, without prior written
  33.  *    permission of the Apache Software Foundation.
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  *
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation, and was
  51.  * originally based on software copyright (c) 2001, International
  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
  53.  * on the Apache Software Foundation, please see
  54.  * <http://www.apache.org/>.
  55.  */
  57. /*
  58.  * $Log: IconvFBSDTransService.cpp,v $
  59.  * Revision 1.14  2003/05/17 16:32:17  knoaman
  60.  * Memory manager implementation : transcoder update.
  61.  *
  62.  * Revision 1.13  2003/05/16 21:37:00  knoaman
  63.  * Memory manager implementation: Modify constructors to pass in the memory manager.
  64.  *
  65.  * Revision 1.12  2003/05/15 18:47:04  knoaman
  66.  * Partial implementation of the configurable memory manager.
  67.  *
  68.  * Revision 1.11  2003/03/09 17:02:57  peiyongz
  69.  * PanicHandler
  70.  *
  71.  * Revision 1.10  2003/03/07 15:08:57  tng
  72.  * [Bug 17571] fix building IconvFBSD (namespaces) .  Patch from Bjoern A. Zeeb.
  73.  *
  74.  * Revision 1.9  2003/03/07 14:42:45  tng
  75.  * [Bug 17570] IconvFBSD build on alpha,sparc.  Patch from Bjoern A. Zeeb.
  76.  *
  77.  * Revision 1.8  2003/02/25 08:15:42  gareth
  78.  * Patch to fix compile problem in bug #17358. Patch by Michael Cahill.
  79.  *
  80.  * Revision 1.7  2002/12/31 18:42:43  tng
  81.  * [Bug 15608] IconvLCPTranscoder::transcode() is wrong at wcstombs() usage.
  82.  *
  83.  * Revision 1.6  2002/11/04 15:14:34  tng
  84.  * C++ Namespace Support.
  85.  *
  86.  * Revision 1.5  2002/07/04 18:20:18  tng
  87.  * [Bug 10253] Bugfix for the IconvFBSD transcoder.   Patch from Max Gotlib.
  88.  *
  89.  * Revision 1.4  2002/04/11 15:38:05  knoaman
  90.  * String lower case support for FreeBSD by Max Gotlib
  91.  *
  92.  * Revision 1.3  2002/04/09 15:44:00  knoaman
  93.  * Add lower case string support.
  94.  *
  95.  * Revision 1.2  2002/03/18 13:39:11  tng
  96.  * [Bug 7162 ] IconvFreeBSDTransService.cpp needs an #include statement fixed to use xercesc.
  97.  *
  98.  * Revision 1.1.1.1  2002/02/01 22:22:36  peiyongz
  99.  * sane_include
  100.  *
  101.  * Revision 1.4  2002/01/14 19:45:15  tng
  102.  * Support IconvFBSD in multi-threading environment with all the possible combinations of threading and transcoding options.  By Max Gotlib.
  103.  *
  104.  * Revision 1.3  2001/12/12 14:48:16  tng
  105.  * More bug fixes in IconvFBSD Transcoder.  By Max Gotlib.
  106.  *
  107.  * Revision 1.2  2001/12/11 15:10:14  tng
  108.  * More changes to IconvFBSDTransService.  Allow using "old" TransServece implementation (via '-t native' option to runConfigure) or
  109.  * to employ libiconv (it is a part of FreeBSD ports-collection) services.  By Max Gotlib.
  110.  *
  111.  * Revision 1.1  2001/12/03 14:45:11  tng
  112.  * FreeBSD native transcoder (IconvFBSD) added by Max Gotlib.
  113.  *
  114.  */
  116. // ---------------------------------------------------------------------------
  117. //  Includes
  118. // ---------------------------------------------------------------------------
  119. #include <ctype.h>
  121. #ifdef XML_USE_LIBICONV
  122. # include <locale.h>
  123. # include <iconv.h>
  124. # include <errno.h>
  125. # include <machine/endian.h>
  127. // ---------------------------------------------------------------------------
  128. // Description of encoding schemas, supported by iconv()
  129. // ---------------------------------------------------------------------------
  130. typedef struct __IconvFBSDEncoding {
  131.     const char*    fSchema;    // schema name
  132.     size_t    fUChSize;    // size of the character
  133.     unsigned int fUBO;        // byte order, relative to the host
  134. } IconvFBSDEncoding;
  136. static const IconvFBSDEncoding    gIconvFBSDEncodings[] = {
  137.     { "ucs-2-internal",        2,    LITTLE_ENDIAN },
  138.     { "ucs2-internal",        2,    LITTLE_ENDIAN },
  139.     { "ucs-4-internal",        4,    LITTLE_ENDIAN },
  140.     { "ucs4-internal",        4,    LITTLE_ENDIAN },
  141.     { "UNICODELITTLE",        2,    LITTLE_ENDIAN },
  142.     { "UNICODEBIG",        2,    BIG_ENDIAN },
  143.     { "iso-10646-ucs-2",    4,    BIG_ENDIAN },
  144.     { "iso-10646-ucs-4",    4,    BIG_ENDIAN },
  145.     /* { "iso-10646-utf-16",    2,    BIG_ENDIAN }, */
  146.     { NULL, 0,     0 }
  147. };
  149. //--------------------------------------------------
  150. // Macro-definitions to translate "native unicode"
  151. // characters <-> XMLCh with different host byte order
  152. // and encoding schemas.
  154. # if BYTE_ORDER == LITTLE_ENDIAN
  155. #  define IXMLCh2WC16(x,w)            
  156.     *(w) = ((*(x)) >> 8) & 0xFF;        
  157.     *((w)+1) = (*(x)) & 0xFF
  158. #  define IWC162XMLCh(w,x)    *(x) = ((*(w)) << 8) | (*((w)+1))
  159. #  define XMLCh2WC16(x,w)            
  160.     *(w) = (*(x)) & 0xFF;            
  161.     *((w)+1) = ((*(x)) >> 8) & 0xFF
  162. #  define WC162XMLCh(w,x)    *(x) = ((*((w)+1)) << 8) | (*(w))
  164. #  define IXMLCh2WC32(x,w)            
  165.     *(w) = ((*(x)) >> 24) & 0xFF;        
  166.     *((w)+1) = ((*(x)) >> 16) & 0xFF;    
  167.     *((w)+2) = ((*(x)) >> 8) & 0xFF;    
  168.     *((w)+3) = (*(x)) & 0xFF
  169. #  define IWC322XMLCh(w,x)                
  170.       *(x) = ((*(w)) << 24) | ((*((w)+1)) << 16) |    
  171.           ((*((w)+2)) << 8) | (*((w)+3))
  172. #  define XMLCh2WC32(x,w)            
  173.     *((w)+3) = ((*(x)) >> 24) & 0xFF;    
  174.     *((w)+2) = ((*(x)) >> 16) & 0xFF;    
  175.     *((w)+1) = ((*(x)) >> 8) & 0xFF;    
  176.     *(w) = (*(x)) & 0xFF
  177. #  define WC322XMLCh(w,x)                    
  178.       *(x) = ((*((w)+3)) << 24) | ((*((w)+2)) << 16) |    
  179.         ((*((w)+1)) << 8) | (*(w))
  181. # else /* BYTE_ORDER != LITTLE_ENDIAN */
  183. #  define XMLCh2WC16(x,w)            
  184.     *(w) = ((*(x)) >> 8) & 0xFF;        
  185.     *((w)+1) = (*(x)) & 0xFF
  186. #  define WC162XMLCh(w,x)    *(x) = ((*(w)) << 8) | (*((w)+1))
  187. #  define IXMLCh2WC16(x,w)            
  188.     *(w) = (*(x)) & 0xFF;            
  189.     *((w)+1) = ((*(x)) >> 8) & 0xFF
  190. #  define IWC162XMLCh(w,x)    *(x) = ((*((w)+1)) << 8) | (*(w))
  192. #  define XMLCh2WC32(x,w)            
  193.     *(w) = ((*(x)) >> 24) & 0xFF;        
  194.     *((w)+1) = ((*(x)) >> 16) & 0xFF;    
  195.     *((w)+2) = ((*(x)) >> 8) & 0xFF;    
  196.     *((w)+3) = (*(x)) & 0xFF
  197. #  define WC322XMLCh(w,x)                
  198.       *(x) = ((*(w)) << 24) | ((*((w)+1)) << 16) |    
  199.           ((*((w)+2)) << 8) | (*((w)+3))
  200. #  define IXMLCh2WC32(x,w)            
  201.     *((w)+3) = ((*(x)) >> 24) & 0xFF;    
  202.     *((w)+2) = ((*(x)) >> 16) & 0xFF;    
  203.     *((w)+1) = ((*(x)) >> 8) & 0xFF;    
  204.     *(w) = (*(x)) & 0xFF
  205. #  define IWC322XMLCh(w,x)                    
  206.       *(x) = ((*((w)+3)) << 24) | ((*((w)+2)) << 16) |    
  207.         ((*((w)+1)) << 8) | (*(w))
  208. # endif /* BYTE_ORDER == LITTLE_ENDIAN */
  210. #else /* !XML_USE_LIBICONV */
  212. # if __FreeBSD_cc_version > 430000
  213. #  include <wchar.h>
  214. # else
  215. #  define wint_t XMLCh
  216. # endif
  218. #endif /* XML_USE_LIBICONV */
  220. #include <xercesc/util/XMLString.hpp>
  221. #include <xercesc/util/XMLUniDefs.hpp>
  222. #include <xercesc/util/XMLUni.hpp>
  223. #include <xercesc/util/PlatformUtils.hpp>
  224. #include <xercesc/util/TranscodingException.hpp>
  225. #include "IconvFBSDTransService.hpp"
  227. #include <string.h>
  228. #include <stdlib.h>
  229. #include <stdio.h>
  231. #if !defined(APP_NO_THREADS)
  232. #include <xercesc/util/Mutexes.hpp>
  233. #endif
  235. XERCES_CPP_NAMESPACE_BEGIN
  237. // ---------------------------------------------------------------------------
  238. //  Local, const data
  239. // ---------------------------------------------------------------------------
  240. static const unsigned int    gTempBuffArraySize = 4096;
  241. static const XMLCh          gMyServiceId[] =
  242. {
  243.     chLatin_I, chLatin_C, chLatin_o, chLatin_n, chLatin_v, chNull
  244. };
  247. // ---------------------------------------------------------------------------
  248. //  Local methods
  249. // ---------------------------------------------------------------------------
  250. static unsigned int getWideCharLength(const XMLCh* const src)
  251. {
  252.     if (!src)
  253.         return 0;
  255.     unsigned int len = 0;
  256.     const XMLCh* pTmp = src;
  257.     while (*pTmp++)
  258.         len++;
  259.     return len;
  260. }
  262. #ifndef XML_USE_LIBICONV
  264. // ---------------------------------------------------------------------------
  265. // FreeBSD got the wide-characters support since 4.0 version. But (at least
  266. // up to the 4.4) this support differs from "others" in that the xxstoyys()
  267. // does not handle the NULL-dest argument properly. So the custom functions
  268. // are provided.
  269. // ---------------------------------------------------------------------------
  271. #define __TMP_ARRAY_SIZE__      4
  273. static size_t fbsd_wcstombs(char *dest, const wchar_t *src, size_t n)
  274. {
  275.     char        tarr[ __TMP_ARRAY_SIZE__ + 1 ];
  276.     size_t      len = 0, lent = 0;
  277.     char*       ptr;
  278.     size_t      slen;
  279.     wchar_t*    wptr;
  281.     if (dest)
  282.         return ::wcstombs(dest, src, n);
  283.     if (!src)
  284.         return 0;
  285.     for (wptr = (wchar_t *) src, slen = 0; *wptr; wptr++, slen++);
  286.     if (slen == 0)
  287.         return 0;
  288.     wptr = (wchar_t *) src;
  289.     ptr = dest;
  290.     while ( (len = ::wcstombs(tarr, wptr, __TMP_ARRAY_SIZE__)) > 0 ) {
  291.         wptr += len;
  292.         lent += len;
  293.     }
  294.     if (len == (unsigned) -1)
  295.         return 0;
  296.     return lent;
  297. }
  299. static size_t fbsd_mbstowcs(wchar_t *dest, const char *src, size_t n)
  300. {
  301.     wchar_t     tarr[ __TMP_ARRAY_SIZE__ + 1 ];
  302.     size_t      len = 0, lent = 0;
  303.     char*       ptr;
  305.     if (dest)
  306.         return ::mbstowcs(dest, src, n);
  307.     ptr = (char*) src;
  308.     if (!src || strlen(src) == 0)
  309.         return 0;
  310.     while ( (len = ::mbstowcs(tarr, ptr, __TMP_ARRAY_SIZE__)) > 0 ) {
  311.         ptr += len;
  312.         lent += len;
  313.     }
  314.     if (len == (unsigned) -1)
  315.         return 0;
  316.     return lent;
  317. }
  319. static wint_t fbsd_towupper(wint_t ch)
  320. {
  321.     if (ch <= 0x7F)
  322.     return toupper(ch);
  323.     unsigned char    buf[16];
  324.     wchar_t    wc = wchar_t(ch);
  325.     wcstombs((char*)buf, &wc, 16);
  326.     return toupper(*buf);
  327. }
  329. static wint_t fbsd_towlower(wint_t ch)
  330. {
  331.     if (ch <= 0x7F)
  332.     return tolower(ch);
  333.     unsigned char    buf[16];
  334.     wchar_t    wc = wchar_t(ch);
  335.     wcstombs((char *)buf, &wc, 16);
  336.     return tolower(*buf);
  337. }
  339. #else /* XML_USE_LIBICONV */
  341. #if !defined(APP_NO_THREADS)
  342. // Iconv() access syncronization point
  343. static XMLMutex    *gIconvMutex = NULL;
  344. #  define ICONV_LOCK    XMLMutexLock lockConverter(gIconvMutex);
  346. #else /* APP_NO_THREADS */
  348. # define ICONV_LOCK
  350. #endif /* !APP_NO_THREADS */
  352. //----------------------------------------------------------------------------
  353. // There is implementation of the libiconv for FreeBSD (available through the
  354. // ports collection). The following is a wrapper around the iconv().
  355. //----------------------------------------------------------------------------
  357. IconvFBSDCD::IconvFBSDCD ()
  358.     : fUChSize(0), fUBO(LITTLE_ENDIAN),
  359.       fCDTo((iconv_t)-1), fCDFrom((iconv_t)-1)
  360. {
  361. }
  363. IconvFBSDCD::IconvFBSDCD ( iconv_t    cd_from,
  364.                iconv_t    cd_to,
  365.                size_t    uchsize,
  366.                unsigned int    ubo )
  367.     : fUChSize(uchsize), fUBO(ubo),
  368.       fCDTo(cd_to), fCDFrom(cd_from)
  369. {
  370.     if (fCDFrom == (iconv_t) -1 || fCDTo == (iconv_t) -1) {
  371.     XMLPlatformUtils::panic (PanicHandler::Panic_NoTransService);
  372.     }
  373. }
  375. IconvFBSDCD::~IconvFBSDCD()
  376. {
  377. }
  379. // Convert "native unicode" character into XMLCh
  380. void    IconvFBSDCD::mbcToXMLCh (const char *mbc, XMLCh *toRet) const
  381. {
  382.     if (fUBO == LITTLE_ENDIAN) {
  383.         if (fUChSize == sizeof(XMLCh))
  384.             *toRet = *((XMLCh*) mbc);
  385.         else if (fUChSize == 2) {
  386.             WC162XMLCh( mbc, toRet );
  387.         } else {
  388.             WC322XMLCh( mbc, toRet );
  389.         }
  390.     } else {
  391.         if (fUChSize == 2) {
  392.             IWC162XMLCh( mbc, toRet );
  393.         } else {
  394.             IWC322XMLCh( mbc, toRet );
  395.         }
  396.     }
  397. }
  399. // Convert XMLCh into "native unicode" character
  400. void    IconvFBSDCD::xmlChToMbc (XMLCh xch, char *mbc) const
  401. {
  402.     if (fUBO == LITTLE_ENDIAN) {
  403.         if (fUChSize == sizeof(XMLCh)) {
  404.             memcpy (mbc, &xch, fUChSize);
  405.             return;
  406.         }
  407.         if (fUChSize == 2) {
  408.             XMLCh2WC16( &xch, mbc );
  409.         } else {
  410.             XMLCh2WC32( &xch, mbc );
  411.         }
  412.     } else {
  413.         if (fUChSize == 2) {
  414.             IXMLCh2WC16( &xch, mbc );
  415.         } else {
  416.             IXMLCh2WC32( &xch, mbc );
  417.         }
  418.     }
  419. }
  421. // Return uppercase equivalent for XMLCh
  422. XMLCh    IconvFBSDCD::toUpper (const XMLCh ch) const
  423. {
  424.     if (ch <= 0x7F)
  425.         return toupper(ch);
  427.     char    wcbuf[fUChSize * 2];
  428.     xmlChToMbc (ch, wcbuf);
  430.     char    tmpArr[4];
  431.     char*    ptr = wcbuf;
  432.     size_t    len = fUChSize;
  433.     char    *pTmpArr = tmpArr;
  434.     size_t    bLen = 2;
  436.     ICONV_LOCK;
  437.     if (::iconv (fCDTo, (const char**) &ptr, &len,
  438.          &pTmpArr, &bLen) == (size_t) -1)
  439.     return 0;
  440.     tmpArr[1] = toupper (*((unsigned char *)tmpArr));
  441.     *tmpArr = tmpArr[1];
  442.     len = 1;
  443.     pTmpArr = wcbuf;
  444.     bLen = fUChSize;
  445.     ptr = tmpArr;
  446.     if (::iconv (fCDFrom, (const char **)&ptr, &len,
  447.          &pTmpArr, &bLen) == (size_t) -1)
  448.     return 0;
  449.     mbcToXMLCh (wcbuf, (XMLCh*) &ch);
  450.     return ch;
  451. }
  453. // Return lowercase equivalent for XMLCh
  454. XMLCh    IconvFBSDCD::toLower (const XMLCh ch) const
  455. {
  456.     if (ch <= 0x7F)
  457.         return tolower(ch);
  459.     char    wcbuf[fUChSize * 2];
  460.     xmlChToMbc (ch, wcbuf);
  462.     char    tmpArr[4];
  463.     char*    ptr = wcbuf;
  464.     size_t    len = fUChSize;
  465.     char    *pTmpArr = tmpArr;
  466.     size_t    bLen = 2;
  468.     ICONV_LOCK;
  469.     if (::iconv (fCDTo, (const char**) &ptr, &len,
  470.          &pTmpArr, &bLen) == (size_t) -1)
  471.     return 0;
  472.     tmpArr[1] = tolower (*((unsigned char*)tmpArr));
  473.     *tmpArr = tmpArr[1];
  474.     len = 1;
  475.     pTmpArr = wcbuf;
  476.     bLen = fUChSize;
  477.     ptr = tmpArr;
  478.     if (::iconv (fCDFrom, (const char **)&ptr, &len,
  479.          &pTmpArr, &bLen) == (size_t) -1)
  480.     return 0;
  481.     mbcToXMLCh (wcbuf, (XMLCh*) &ch);
  482.     return ch;
  483. }
  485. // Check if passed characters belongs to the :space: class
  486. bool    IconvFBSDCD::isSpace(const XMLCh toCheck) const
  487. {
  488.     if (toCheck <= 0x7F)
  489.         return isspace(toCheck);
  491.     char    wcbuf[fUChSize * 2];
  492.     char    tmpArr[4];
  494.     xmlChToMbc (toCheck, wcbuf);
  495.     char*    ptr = wcbuf;
  496.     size_t    len = fUChSize;
  497.     char    *pTmpArr = tmpArr;
  498.     size_t    bLen = 2;
  500.     {
  501.         ICONV_LOCK;
  502.         if (::iconv (fCDTo, (const char**) &ptr, &len,
  503.                  &pTmpArr, &bLen) == (size_t) -1)
  504.             return 0;
  505.     }
  506.     return isspace(*tmpArr);
  507. }
  509. // Fill array of XMLCh characters with data, supplyed in the array
  510. // of "native unicode" characters.
  511. XMLCh*    IconvFBSDCD::mbsToXML
  512. (
  513.     const char*        mbs_str
  514.     ,       size_t    mbs_cnt
  515.     ,       XMLCh*    xml_str
  516.     ,       size_t    xml_cnt
  517. ) const
  518. {
  519.     if (mbs_str == NULL || mbs_cnt == 0 || xml_str == NULL || xml_cnt == 0)
  520.         return NULL;
  521.     size_t    cnt = (mbs_cnt < xml_cnt) ? mbs_cnt : xml_cnt;
  522.     if (fUBO == LITTLE_ENDIAN) {
  523.     if (fUChSize == sizeof(XMLCh)) {
  524.         // null-transformation
  525.         memcpy (xml_str, mbs_str, fUChSize * cnt);
  526.         return xml_str;
  527.     }
  528.     if (fUChSize == 2)
  529.         for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize) {
  530.             WC162XMLCh( mbs_str, xml_str + i);
  531.         }
  532.     else
  533.         for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize) {
  534.             WC322XMLCh( mbs_str, xml_str + i );
  535.         }
  536.     } else {
  537.         if (fUChSize == 2)
  538.             for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize) {
  539.                 IWC162XMLCh( mbs_str, xml_str + i );
  540.             }
  541.         else
  542.             for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize) {
  543.                 IWC322XMLCh( mbs_str, xml_str + i );
  544.             }
  545.     }
  546.     return xml_str;
  547. }
  549. // Fill array of "native unicode" characters with data, supplyed
  550. // in the array of XMLCh characters.
  551. char*    IconvFBSDCD::xmlToMbs
  552. (
  553.     const XMLCh*    xml_str
  554.     ,      size_t    xml_cnt
  555.     ,      char*        mbs_str
  556.     ,      size_t    mbs_cnt
  557. ) const
  558. {
  559.     if (mbs_str == NULL || mbs_cnt == 0 || xml_str == NULL || xml_cnt == 0)
  560.         return NULL;
  561.     size_t    cnt = (mbs_cnt < xml_cnt) ? mbs_cnt : xml_cnt;
  562.     char    *toReturn = mbs_str;
  563.     if (fUBO == LITTLE_ENDIAN) {
  564.         if (fUChSize == sizeof(XMLCh)) {
  565.             // null-transformation
  566.             memcpy (mbs_str, xml_str, fUChSize * cnt);
  567.             return toReturn;
  568.         }
  569.         if (fUChSize == 2)
  570.             for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize, xml_str++) {
  571.                 XMLCh2WC16( xml_str, mbs_str );
  572.             }
  573.         else
  574.             for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize, xml_str++) {
  575.                 XMLCh2WC32( xml_str, mbs_str );
  576.             }
  577.     } else {
  578.         if (fUChSize == 2)
  579.             for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize, xml_str++) {
  580.                 IXMLCh2WC16( xml_str, mbs_str );
  581.             }
  582.         else
  583.             for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize, xml_str++) {
  584.                 IXMLCh2WC32( xml_str, mbs_str );
  585.             }
  586.     }
  587.     return toReturn;
  588. }
  590. size_t    IconvFBSDCD::iconvFrom ( const char    *fromPtr,
  591.                  size_t        *fromLen,
  592.                  char        **toPtr,
  593.                  size_t        toLen ) const
  594. {
  595.     ICONV_LOCK;
  596.     return ::iconv (fCDFrom, &fromPtr, fromLen, toPtr, &toLen);
  597. }
  599. size_t    IconvFBSDCD::iconvTo ( const char    *fromPtr,
  600.                    size_t        *fromLen,
  601.                    char        **toPtr,
  602.                    size_t        toLen ) const
  603. {
  604.     ICONV_LOCK;
  605.     return ::iconv (fCDTo, &fromPtr, fromLen, toPtr, &toLen);
  606. }
  608. #endif /* !XML_USE_LIBICONV */
  611. // ---------------------------------------------------------------------------
  612. //  IconvFBSDTransService: Constructors and Destructor
  613. // ---------------------------------------------------------------------------
  615. IconvFBSDTransService::IconvFBSDTransService()
  616. #ifndef XML_USE_LIBICONV
  617. {}
  618. #else  /* XML_USE_LIBICONV */
  619.     : IconvFBSDCD(), fUnicodeCP(0)
  620. {
  621. #if !defined(APP_NO_THREADS)
  622.     // Create global lock object
  623.     if (gIconvMutex == NULL) {
  624.         gIconvMutex = new XMLMutex;
  625.         if (gIconvMutex == NULL)
  626.             XMLPlatformUtils::panic (PanicHandler::Panic_NoTransService);
  627.     }
  628. #endif
  630.     // Try to obtain local (host) characterset through the environment
  631.     char*    fLocalCP = setlocale (LC_CTYPE, "");
  632.     if (fLocalCP == NULL)
  633.         fLocalCP = "iso-8859-1";    // fallback locale
  634.     else {
  635.         char    *ptr = strchr (fLocalCP, '.');
  636.         if (ptr == NULL)
  637.             fLocalCP = "iso-8859-1";    // fallback locale
  638.         else
  639.             fLocalCP = ptr + 1;
  640.     }
  642.     // Select the native unicode characters encoding schema
  643.     const IconvFBSDEncoding    *eptr;
  644.     // first - try to use the schema with character size, equil to XMLCh
  645.     for (eptr = gIconvFBSDEncodings; eptr->fSchema; eptr++) {
  646.         if (eptr->fUChSize != sizeof(XMLCh))
  647.             continue;
  648.         ICONV_LOCK;
  649.         // try to create conversion descriptor
  650.         iconv_t    cd_to = iconv_open(fLocalCP, eptr->fSchema);
  651.         if (cd_to == (iconv_t)-1)
  652.             continue;
  653.         iconv_t    cd_from = iconv_open(eptr->fSchema, fLocalCP);
  654.         if (cd_to == (iconv_t)-1) {
  655.             iconv_close (cd_to);
  656.             continue;
  657.         }
  658.         // got it
  659.         setUChSize(eptr->fUChSize);
  660.         setUBO(eptr->fUBO);
  661.         setCDTo(cd_to);
  662.         setCDFrom(cd_from);
  663.         fUnicodeCP = eptr->fSchema;
  664.         break;
  665.     }
  666.     if (fUnicodeCP == NULL)
  667.         // try to use any known schema
  668.         for (eptr = gIconvFBSDEncodings; eptr->fSchema; eptr++) {
  669.             // try to create conversion descriptor
  670.             ICONV_LOCK;
  671.             iconv_t    cd_to = iconv_open(fLocalCP, eptr->fSchema);
  672.             if (cd_to == (iconv_t)-1)
  673.             continue;
  674.             iconv_t    cd_from = iconv_open(eptr->fSchema, fLocalCP);
  675.             if (cd_to == (iconv_t)-1) {
  676.             iconv_close (cd_to);
  677.             continue;
  678.         }
  679.         // got it
  680.         setUChSize(eptr->fUChSize);
  681.         setUBO(eptr->fUBO);
  682.         setCDTo(cd_to);
  683.         setCDFrom(cd_from);
  684.         fUnicodeCP = eptr->fSchema;
  685.         break;
  686.     }
  688.     if (fUnicodeCP == NULL || cdTo() == (iconv_t)-1 || cdFrom() == (iconv_t)-1)
  689.     XMLPlatformUtils::panic (PanicHandler::Panic_NoTransService);
  690. }
  691. #endif /* XML_USE_LIBICONV */
  693. IconvFBSDTransService::~IconvFBSDTransService()
  694. {
  695. #ifdef XML_USE_LIBICONV
  696.     if (cdTo() != (iconv_t) -1) {
  697.         iconv_close (cdTo());
  698.         setCDTo ((iconv_t)-1);
  699.     }
  700.     if (cdFrom() != (iconv_t) -1) {
  701.         iconv_close (cdFrom());
  702.         setCDFrom ((iconv_t)-1);
  703.     }
  704. #endif /* XML_USE_LIBICONV */
  705. }
  707. // ---------------------------------------------------------------------------
  708. //  IconvFBSDTransService: The virtual transcoding service API
  709. // ---------------------------------------------------------------------------
  710. int IconvFBSDTransService::compareIString(const XMLCh* const    comp1
  711.                                         , const XMLCh* const    comp2)
  712. {
  713.     const XMLCh* cptr1 = comp1;
  714.     const XMLCh* cptr2 = comp2;
  716. #ifndef XML_USE_LIBICONV
  718.     while ( (*cptr1 != 0) && (*cptr2 != 0) ) {
  719.         wint_t wch1 = fbsd_towupper(*cptr1);
  720.         wint_t wch2 = fbsd_towupper(*cptr2);
  721.         if (wch1 != wch2)
  722.             break;
  723.         cptr1++;
  724.         cptr2++;
  725.     }
  726.     return (int) ( fbsd_towupper(*cptr1) - fbsd_towupper(*cptr2) );
  728. #else /* XML_USE_LIBICONV */
  730.     XMLCh    c1 = toUpper(*cptr1);
  731.     XMLCh    c2 = toUpper(*cptr2);
  732.     while ( (*cptr1 != 0) && (*cptr2 != 0) ) {
  733.         if (c1 != c2)
  734.             break;
  735.         c1 = toUpper(*(++cptr1));
  736.         c2 = toUpper(*(++cptr2));
  738.     }
  739.     return (int) ( c1 - c2 );
  741. #endif /* !XML_USE_LIBICONV */
  742. }
  745. int IconvFBSDTransService::compareNIString(const XMLCh* const    comp1
  746.                                          , const XMLCh* const    comp2
  747.                                          , const unsigned int    maxChars)
  748. {
  749.     unsigned int  n = 0;
  750.     const XMLCh* cptr1 = comp1;
  751.     const XMLCh* cptr2 = comp2;
  753. #ifndef XML_USE_LIBICONV
  755.     while (true && maxChars)
  756.     {
  757.         wint_t wch1 = fbsd_towupper(*cptr1);
  758.         wint_t wch2 = fbsd_towupper(*cptr2);
  760.         if (wch1 != wch2)
  761.             return (int) (wch1 - wch2);
  763.         // If either ended, then both ended, so equal
  764.         if (!*cptr1 || !*cptr2)
  765.             break;
  767.         cptr1++;
  768.         cptr2++;
  770.         //  Bump the count of chars done. If it equals the count then we
  771.         //  are equal for the requested count, so break out and return
  772.         //  equal.
  773.         n++;
  774.         if (n == maxChars)
  775.             break;
  776.     }
  778. #else /* XML_USE_LIBICONV */
  780.     while (true && maxChars)
  781.     {
  782.         XMLCh    c1 = toUpper(*cptr1);
  783.         XMLCh    c2 = toUpper(*cptr2);
  785.         if (c1 != c2)
  786.             return (int) (c1 - c2);
  788.         // If either ended, then both ended, so equal
  789.         if (!*cptr1 || !*cptr2)
  790.             break;
  792.         cptr1++;
  793.         cptr2++;
  795.         //  Bump the count of chars done. If it equals the count then we
  796.         //  are equal for the requested count, so break out and return
  797.         //  equal.
  798.         n++;
  799.         if (n == maxChars)
  800.             break;
  801.     }
  803. #endif /* !XML_USE_LIBICONV */
  805.     return 0;
  806. }
  809. const XMLCh* IconvFBSDTransService::getId() const
  810. {
  811.     return gMyServiceId;
  812. }
  815. bool IconvFBSDTransService::isSpace(const XMLCh toCheck) const
  816. {
  817. #ifndef XML_USE_LIBICONV
  818.     if (toCheck <= 0x7F)
  819.         return isspace(toCheck);
  820.     char buf[16];
  821.     wchar_t    wc = wchar_t(toCheck);
  822.     wcstombs( buf, &wc, 16 );
  823.     return (isspace(*buf) != 0);
  824. #else /* XML_USE_LIBICONV */
  825.     return IconvFBSDCD::isSpace(toCheck);
  826. #endif /* !XML_USE_LIBICONV */
  827. }
  830. XMLLCPTranscoder* IconvFBSDTransService::makeNewLCPTranscoder()
  831. {
  832.     // Just allocate a new transcoder of our type
  833. #ifndef XML_USE_LIBICONV
  834.     return new IconvFBSDLCPTranscoder;
  835. #else /* XML_USE_LIBICONV */
  836.     return new IconvFBSDLCPTranscoder (cdFrom(), cdTo(), uChSize(), UBO());
  837. #endif /* !XML_USE_LIBICONV */
  838. }
  840. bool IconvFBSDTransService::supportsSrcOfs() const
  841. {
  842.     return true;
  843. }
  845. // ---------------------------------------------------------------------------
  846. //  IconvFBSDTransService: The protected virtual transcoding service API
  847. // ---------------------------------------------------------------------------
  848. XMLTranscoder*
  849. IconvFBSDTransService::makeNewXMLTranscoder
  850. (
  851.     const    XMLCh* const    encodingName
  852.     ,    XMLTransService::Codes&    resValue
  853.     , const     unsigned int    blockSize
  854.     ,       MemoryManager* const    manager
  855. )
  856. {
  857. #ifndef XML_USE_LIBICONV
  858.     //
  859.     //  NOTE: We don't use the block size here
  860.     //
  861.     //  This is a minimalist transcoding service, that only supports a local
  862.     //  default transcoder. All named encodings return zero as a failure,
  863.     //  which means that only the intrinsic encodings supported by the parser
  864.     //  itself will work for XML data.
  865.     //
  866.     resValue = XMLTransService::UnsupportedEncoding;
  867.     return 0;
  868. #else /* XML_USE_LIBICONV */
  870.     resValue = XMLTransService::UnsupportedEncoding;
  871.     IconvFBSDTranscoder    *newTranscoder = NULL;
  873.     char    *encLocal = XMLString::transcode(encodingName, manager);
  874.     iconv_t    cd_from, cd_to;
  876.     {
  877.         ICONV_LOCK;
  878.         cd_from = iconv_open (fUnicodeCP, encLocal);
  879.         if (cd_from == (iconv_t)-1) {
  880.             resValue = XMLTransService::SupportFilesNotFound;
  881.             if (encLocal)
  882.             manager->deallocate(encLocal);//delete [] encLocal;
  883.             return NULL;
  884.         }
  885.         cd_to = iconv_open (encLocal, fUnicodeCP);
  886.         if (cd_to == (iconv_t)-1) {
  887.             resValue = XMLTransService::SupportFilesNotFound;
  888.             iconv_close (cd_from);
  889.             if (encLocal)
  890.             manager->deallocate(encLocal);//delete [] encLocal;
  891.             return NULL;
  892.         }
  893.         newTranscoder = new (manager) IconvFBSDTranscoder (encodingName,
  894.                              blockSize,
  895.                              cd_from, cd_to,
  896.                              uChSize(), UBO(),
  897.                              manager);
  898.     }
  899.     if (newTranscoder)
  900.         resValue = XMLTransService::Ok;
  901.     if (encLocal)
  902.         manager->deallocate(encLocal);//delete [] encLocal;
  903.     return newTranscoder;
  905. #endif /* !XML_USE_LIBICONV */
  906. }
  908. void IconvFBSDTransService::upperCase(XMLCh* const toUpperCase) const
  909. {
  910.     XMLCh* outPtr = toUpperCase;
  911.     while (*outPtr)
  912.     {
  913. #ifndef XML_USE_LIBICONV
  914.         *outPtr = fbsd_towupper(*outPtr);
  915. #else /* XML_USE_LIBICONV */
  916.         *outPtr = toUpper(*outPtr);
  917. #endif /* !XML_USE_LIBICONV */
  918.         outPtr++;
  919.     }
  920. }
  922. void IconvFBSDTransService::lowerCase(XMLCh* const toLowerCase) const
  923. {
  924.     XMLCh* outPtr = toLowerCase;
  925.     while (*outPtr)
  926.     {
  927. #ifndef XML_USE_LIBICONV
  928.         *outPtr = fbsd_towlower(*outPtr);
  929. #else /* XML_USE_LIBICONV */
  930.         *outPtr = toLower(*outPtr);
  931. #endif /* !XML_USE_LIBICONV */
  932.         outPtr++;
  933.     }
  934. }
  936. // ---------------------------------------------------------------------------
  937. //  IconvFBSDLCPTranscoder: The virtual transcoder API
  938. // ---------------------------------------------------------------------------
  939. unsigned int
  940. IconvFBSDLCPTranscoder::calcRequiredSize (const char* const srcText)
  941. {
  942.     if (!srcText)
  943.         return 0;
  945. #ifndef XML_USE_LIBICONV
  947.     unsigned int retVal = fbsd_mbstowcs(NULL, srcText, 0);
  948.     if (retVal == ~0)
  949.         return 0;
  950.     return retVal;
  952. #else /* XML_USE_LIBICONV */
  954.     size_t      len, srcLen;
  955.     len = srcLen = strlen(srcText);
  956.     if (len == 0)
  957.         return 0;
  959.     char    tmpWideArr[gTempBuffArraySize];
  960.     size_t    totalLen = 0;
  962.     for (;;) {
  963.         char        *pTmpArr = tmpWideArr;
  964.         const char    *ptr = srcText + srcLen - len;
  965.         size_t    rc = iconvFrom(ptr, &len, &pTmpArr, gTempBuffArraySize);
  966.         if (rc == (size_t) -1 && errno != E2BIG) {
  967.             ThrowXML(TranscodingException, XMLExcepts::Trans_BadSrcSeq);
  968.             /* return 0; */
  969.         }
  970.         rc = pTmpArr - (char *) tmpWideArr;
  971.         totalLen += rc;
  972.         if (rc == 0 || len == 0)
  973.             break;
  974.     }
  975.     return totalLen / uChSize();
  977. #endif /* XML_USE_LIBICONV */
  978. }
  981. unsigned int
  982. IconvFBSDLCPTranscoder::calcRequiredSize(const XMLCh* const srcText)
  983. {
  984.     if (!srcText)
  985.         return 0;
  986.     unsigned int  wLent = getWideCharLength(srcText);
  987.     if (wLent == 0)
  988.         return 0;
  990. #ifndef XML_USE_LIBICONV
  992.     wchar_t       tmpWideCharArr[gTempBuffArraySize];
  993.     wchar_t*      allocatedArray = 0;
  994.     wchar_t*      wideCharBuf = 0;
  996.     if (wLent >= gTempBuffArraySize)
  997.         wideCharBuf = allocatedArray = (wchar_t*) XMLPlatformUtils::fgMemoryManager->allocate
  998.         (
  999.             (wLent + 1) * sizeof(wchar_t)
  1000.         );//new wchar_t[wLent + 1];
  1001.     else
  1002.         wideCharBuf = tmpWideCharArr;
  1004.     for (unsigned int i = 0; i < wLent; i++)
  1005.         wideCharBuf[i] = srcText[i];
  1006.     wideCharBuf[wLent] = 0x00;
  1008.     const unsigned int retVal = fbsd_wcstombs(NULL, wideCharBuf, 0);
  1010.     if (allocatedArray)
  1011.         XMLPlatformUtils::fgMemoryManager->deallocate(allocatedArray);//delete [] allocatedArray;
  1012.     if (retVal == ~0)
  1013.         return 0;
  1014.     return retVal;
  1016. #else /* XML_USE_LIBICONV */
  1018.     char    tmpWBuff[gTempBuffArraySize];
  1019.     char    *wBuf = 0;
  1020.     char    *wBufPtr = 0;
  1021.     size_t      len = wLent * uChSize();
  1022.     if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
  1023.         if (len > gTempBuffArraySize) {
  1024.             wBufPtr = (char*) XMLPlatformUtils::fgMemoryManager->allocate
  1025.             (
  1026.                 len * sizeof(char)
  1027.             );//new char[len];
  1028.             if (wBufPtr == NULL)
  1029.             return 0;
  1030.             wBuf = wBufPtr;
  1031.         } else
  1032.             wBuf = tmpWBuff;
  1033.         xmlToMbs (srcText, wLent, wBuf, wLent);
  1034.     } else
  1035.     wBuf = (char *) srcText;
  1037.     char    tmpBuff[gTempBuffArraySize];
  1038.     size_t    totalLen = 0;
  1039.     char    *srcEnd = wBuf + wLent * uChSize();
  1041.     for (;;) {
  1042.         char        *pTmpArr = tmpBuff;
  1043.         const char    *ptr = srcEnd - len;
  1044.         size_t    rc = iconvTo(ptr, &len, &pTmpArr, gTempBuffArraySize);
  1045.         if (rc == (size_t) -1 && errno != E2BIG) {
  1046.             if (wBufPtr)
  1047.             XMLPlatformUtils::fgMemoryManager->deallocate(wBufPtr);//delete [] wBufPtr;
  1048.             ThrowXML(TranscodingException, XMLExcepts::Trans_BadSrcSeq);
  1049.             /* return 0; */
  1050.         }
  1051.         rc = pTmpArr - tmpBuff;
  1052.         totalLen += rc;
  1053.         if (rc == 0 || len == 0)
  1054.             break;
  1055.     }
  1056.     if (wBufPtr)
  1057.     XMLPlatformUtils::fgMemoryManager->deallocate(wBufPtr);//delete [] wBufPtr;
  1058.     return totalLen;
  1060. #endif /* !XML_USE_LIBICONV */
  1061. }
  1064. char* IconvFBSDLCPTranscoder::transcode(const XMLCh* const toTranscode)
  1065. {
  1066.     if (!toTranscode)
  1067.         return 0;
  1069.     char* retVal = 0;
  1070.     if (*toTranscode) {
  1071.         unsigned int  wLent = getWideCharLength(toTranscode);
  1073. #ifndef XML_USE_LIBICONV
  1075.         wchar_t       tmpWideCharArr[gTempBuffArraySize];
  1076.         wchar_t*      allocatedArray = 0;
  1077.         wchar_t*      wideCharBuf = 0;
  1079.         if (wLent >= gTempBuffArraySize)
  1080.             wideCharBuf = allocatedArray = new wchar_t[wLent + 1];
  1081.         else
  1082.             wideCharBuf = tmpWideCharArr;
  1084.         for (unsigned int i = 0; i < wLent; i++)
  1085.             wideCharBuf[i] = toTranscode[i];
  1086.         wideCharBuf[wLent] = 0x00;
  1088.         // Calc the needed size.
  1089.         const size_t neededLen = fbsd_wcstombs(NULL, wideCharBuf, 0);
  1090.         if (neededLen == -1) {
  1091.             if (allocatedArray)
  1092.                 delete [] allocatedArray;
  1093.             return 0;
  1094.         }
  1096.         retVal = new char[neededLen + 1];
  1097.         fbsd_wcstombs(retVal, wideCharBuf, neededLen);
  1098.         if (allocatedArray)
  1099.             delete [] allocatedArray;
  1100.         retVal[neededLen] = 0;
  1102. #else /* XML_USE_LIBICONV */
  1104.         // Calc needed size.
  1105.         const size_t neededLen = calcRequiredSize (toTranscode);
  1106.         if (neededLen == 0)
  1107.             return 0;
  1108.         // allocate output buffer
  1109.         retVal = new char[neededLen + 1];
  1110.         if (retVal == NULL)
  1111.             return 0;
  1112.         // prepare the original
  1113.         char    tmpWBuff[gTempBuffArraySize];
  1114.         char    *wideCharBuf = 0;
  1115.         char    *wBufPtr = 0;
  1116.         size_t  len = wLent * uChSize();
  1118.         if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
  1119.             if (len > gTempBuffArraySize) {
  1120.             wBufPtr = new char[len];
  1121.             if (wBufPtr == NULL)
  1122.                 return 0;
  1123.             wideCharBuf = wBufPtr;
  1124.             } else
  1125.             wideCharBuf = tmpWBuff;
  1126.             xmlToMbs (toTranscode, wLent, wideCharBuf, wLent);
  1127.         } else
  1128.             wideCharBuf = (char *) toTranscode;
  1130.         // perform conversion
  1131.         wLent *= uChSize();
  1132.         char    *ptr = retVal;
  1133.         size_t  tmpwLent = wLent;
  1134.         size_t  rc = iconvTo(wideCharBuf, &tmpwLent, &ptr, neededLen);
  1135.         if (rc == (size_t)-1) {
  1136.             if (wBufPtr)
  1137.             delete [] wBufPtr;
  1138.             return 0;
  1139.         }
  1140.         if (wBufPtr)
  1141.             delete [] wBufPtr;
  1142.         retVal[neededLen] = 0;
  1144. #endif /* !XML_USE_LIBICONV */
  1146.     } else {
  1147.         retVal = new char[1];
  1148.         if (retVal == NULL)
  1149.             return 0;
  1150.         retVal[0] = 0;
  1151.     }
  1152.     return retVal;
  1153. }
  1155. char* IconvFBSDLCPTranscoder::transcode(const XMLCh* const toTranscode,
  1156.                                         MemoryManager* const manager)
  1157. {
  1158.     if (!toTranscode)
  1159.         return 0;
  1161.     char* retVal = 0;
  1162.     if (*toTranscode) {
  1163.         unsigned int  wLent = getWideCharLength(toTranscode);
  1165. #ifndef XML_USE_LIBICONV
  1167.         wchar_t       tmpWideCharArr[gTempBuffArraySize];
  1168.         wchar_t*      allocatedArray = 0;
  1169.         wchar_t*      wideCharBuf = 0;
  1171.         if (wLent >= gTempBuffArraySize)
  1172.             wideCharBuf = allocatedArray = (wchar_t*) manager->allocate
  1173.             (
  1174.                 (wLent + 1) * sizeof(wchar_t)
  1175.             );//new wchar_t[wLent + 1];
  1176.         else
  1177.             wideCharBuf = tmpWideCharArr;
  1179.         for (unsigned int i = 0; i < wLent; i++)
  1180.             wideCharBuf[i] = toTranscode[i];
  1181.         wideCharBuf[wLent] = 0x00;
  1183.         // Calc the needed size.
  1184.         const size_t neededLen = fbsd_wcstombs(NULL, wideCharBuf, 0);
  1185.         if (neededLen == -1) {
  1186.             if (allocatedArray)
  1187.                 manager->deallocate(allocatedArray);//delete [] allocatedArray;
  1188.             return 0;
  1189.         }
  1191.         retVal = (char*) manager->allocate((neededLen + 1) * sizeof(char));//new char[neededLen + 1];
  1192.         fbsd_wcstombs(retVal, wideCharBuf, neededLen);
  1193.         if (allocatedArray)
  1194.             manager->deallocate(allocatedArray);//delete [] allocatedArray;
  1195.         retVal[neededLen] = 0;
  1197. #else /* XML_USE_LIBICONV */
  1199.         // Calc needed size.
  1200.         const size_t neededLen = calcRequiredSize (toTranscode);
  1201.         if (neededLen == 0)
  1202.             return 0;
  1203.         // allocate output buffer
  1204.         retVal = (char*) manager->allocate((neededLen + 1) * sizeof(char));//new char[neededLen + 1];
  1205.         if (retVal == NULL)
  1206.             return 0;
  1207.         // prepare the original
  1208.         char    tmpWBuff[gTempBuffArraySize];
  1209.         char    *wideCharBuf = 0;
  1210.         char    *wBufPtr = 0;
  1211.         size_t  len = wLent * uChSize();
  1213.         if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
  1214.             if (len > gTempBuffArraySize) {
  1215.             wBufPtr = (char*) manager->allocate(len * sizeof(char));//new char[len];
  1216.             if (wBufPtr == NULL) {
  1217.                 manager->deallocate(retVal);
  1218.                 return 0;
  1219.             }
  1220.             wideCharBuf = wBufPtr;
  1221.             } else
  1222.             wideCharBuf = tmpWBuff;
  1223.             xmlToMbs (toTranscode, wLent, wideCharBuf, wLent);
  1224.         } else
  1225.             wideCharBuf = (char *) toTranscode;
  1227.         // perform conversion
  1228.         wLent *= uChSize();
  1229.         char    *ptr = retVal;
  1230.         size_t  tmpwLent = wLent;
  1231.         size_t  rc = iconvTo(wideCharBuf, &tmpwLent, &ptr, neededLen);
  1232.         if (rc == (size_t)-1) {
  1233.             if (wBufPtr)
  1234.                 manager->deallocate(wBufPtr);//delete [] wBufPtr;
  1235.             return 0;
  1236.         }
  1237.         if (wBufPtr)
  1238.             manager->deallocate(wBufPtr);//delete [] wBufPtr;
  1239.         retVal[neededLen] = 0;
  1241. #endif /* !XML_USE_LIBICONV */
  1243.     } else {
  1244.         retVal = (char*) manager->allocate(sizeof(char));//new char[1];
  1245.         if (retVal == NULL)
  1246.             return 0;
  1247.         retVal[0] = 0;
  1248.     }
  1249.     return retVal;
  1250. }
  1253. bool IconvFBSDLCPTranscoder::transcode( const   XMLCh* const    toTranscode
  1254.                     , char* const        toFill
  1255.                     , const unsigned int    maxBytes)
  1256. {
  1257.     // Watch for a couple of pyscho corner cases
  1258.     if (!toTranscode || !maxBytes) {
  1259.         toFill[0] = 0;
  1260.         return true;
  1261.     }
  1262.     if (!*toTranscode) {
  1263.         toFill[0] = 0;
  1264.         return true;
  1265.     }
  1267.     unsigned int  wLent = getWideCharLength(toTranscode);
  1268.     if (wLent > maxBytes)
  1269.         wLent = maxBytes;
  1271.     size_t mblen;
  1273. #ifndef XML_USE_LIBICONV
  1275.     wchar_t       tmpWideCharArr[gTempBuffArraySize];
  1276.     wchar_t*      allocatedArray = 0;
  1277.     wchar_t*      wideCharBuf = 0;
  1279.     if (maxBytes >= gTempBuffArraySize)
  1280.         wideCharBuf = allocatedArray = (wchar_t*) XMLPlatformUtils::fgMemoryManager->allocate
  1281.         (
  1282.             (maxBytes + 1) * sizeof(wchar_t)
  1283.         );//new wchar_t[maxBytes + 1];
  1284.     else
  1285.         wideCharBuf = tmpWideCharArr;
  1287.     for (unsigned int i = 0; i < wLent; i++)
  1288.         wideCharBuf[i] = toTranscode[i];
  1289.     wideCharBuf[wLent] = 0x00;
  1291.     // Ok, go ahead and try the transcoding. If it fails, then ...
  1292.     mblen = fbsd_wcstombs(toFill, wideCharBuf, maxBytes);
  1293.     if (mblen == -1) {
  1294.         if (allocatedArray)
  1295.             XMLPlatformUtils::fgMemoryManager->deallocate(allocatedArray);//delete [] allocatedArray;
  1296.         return false;
  1297.     }
  1298.     if (allocatedArray)
  1299.         XMLPlatformUtils::fgMemoryManager->deallocate(allocatedArray);//delete [] allocatedArray;
  1301. #else /* XML_USE_LIBICONV */
  1303.     // Fill the "unicode" string
  1304.     char    tmpWBuff[gTempBuffArraySize];
  1305.     char    *wideCharBuf = 0;
  1306.     char    *wBufPtr = 0;
  1307.     size_t  len = wLent * uChSize();
  1309.     if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
  1310.         if (len > gTempBuffArraySize) {
  1311.             wBufPtr = (char*) XMLPlatformUtils::fgMemoryManager->allocate
  1312.             (
  1313.                 len * sizeof(char)
  1314.             );//new char[len];
  1315.             if (wBufPtr == NULL)
  1316.                 return 0;
  1317.             wideCharBuf = wBufPtr;
  1318.          }
  1319.          else
  1320.              wideCharBuf = tmpWBuff;
  1321.              xmlToMbs (toTranscode, wLent, wideCharBuf, wLent);
  1322.      }
  1323.      else
  1324.          wideCharBuf = (char *) toTranscode;
  1326.     // Ok, go ahead and try the transcoding. If it fails, then ...
  1327.     char    *ptr = toFill;
  1328.     mblen = iconvTo(wideCharBuf, &len, &ptr, maxBytes);
  1329.     if (mblen == (size_t)-1) {
  1330.         if (wBufPtr)
  1331.            XMLPlatformUtils::fgMemoryManager->deallocate(wBufPtr);//delete [] wBufPtr;
  1332.         return false;
  1333.     }
  1334.     if (wBufPtr)
  1335.         XMLPlatformUtils::fgMemoryManager->deallocate(wBufPtr);//delete [] wBufPtr;
  1337. #endif /* !XML_USE_LIBICONV */
  1339.     // Cap it off just in case
  1340.     toFill[mblen] = 0;
  1341.     return true;
  1342. }
  1346. XMLCh* IconvFBSDLCPTranscoder::transcode(const char* const toTranscode)
  1347. {
  1348.     if (!toTranscode)
  1349.         return 0;
  1351.     XMLCh* retVal = 0;
  1352.     if (*toTranscode) {
  1353.         const unsigned int wLent = calcRequiredSize(toTranscode);
  1354.         if (wLent == 0) {
  1355.             retVal = new XMLCh[1];
  1356.             retVal[0] = 0;
  1357.             return retVal;
  1358.         }
  1360. #ifndef XML_USE_LIBICONV
  1362.         wchar_t       tmpWideCharArr[gTempBuffArraySize];
  1363.         wchar_t*      allocatedArray = 0;
  1364.         wchar_t*      wideCharBuf = 0;
  1366.         if (wLent >= gTempBuffArraySize)
  1367.             wideCharBuf = allocatedArray = new wchar_t[wLent + 1];
  1368.         else
  1369.             wideCharBuf = tmpWideCharArr;
  1371.         fbsd_mbstowcs(wideCharBuf, toTranscode, wLent);
  1372.         retVal = new XMLCh[wLent + 1];
  1373.         if (retVal == NULL) {
  1374.             if (allocatedArray)
  1375.                 delete [] allocatedArray;
  1376.             return NULL;
  1377.         }
  1378.         for (unsigned int i = 0; i < wLent; i++)
  1379.             retVal[i] = (XMLCh) wideCharBuf[i];
  1380.         retVal[wLent] = 0x00;
  1381.         if (allocatedArray)
  1382.             delete [] allocatedArray;
  1384. #else /* XML_USE_LIBICONV */
  1386.         char    tmpWBuff[gTempBuffArraySize];
  1387.         char    *wideCharBuf = 0;
  1388.         char    *wBufPtr = 0;
  1389.         size_t  len = wLent * uChSize();
  1391.         retVal = new XMLCh[wLent + 1];
  1392.         if (retVal == NULL)
  1393.             return NULL;
  1394.         if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
  1395.             if (len > gTempBuffArraySize) {
  1396.                 wBufPtr = new char[len];
  1397.                 if (wBufPtr == NULL)
  1398.                     return 0;
  1399.                 wideCharBuf = wBufPtr;
  1400.             } else
  1401.                 wideCharBuf = tmpWBuff;
  1402.         } else
  1403.             wideCharBuf = (char *) retVal;
  1405.         size_t    flen = strlen(toTranscode);
  1406.         char    *ptr = wideCharBuf;
  1407.         size_t    rc = iconvFrom(toTranscode, &flen, &ptr, len);
  1408.         if (rc == (size_t) -1) {
  1409.             if (wBufPtr)
  1410.             delete [] wBufPtr;
  1411.             return NULL;
  1412.         }
  1413.         if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER)
  1414.             mbsToXML (wideCharBuf, wLent, retVal, wLent);
  1415.         if (wBufPtr)
  1416.             delete [] wBufPtr;
  1417.         retVal[wLent] = 0x00;
  1419. #endif /* !XML_USE_LIBICONV */
  1421.     }
  1422.     else {
  1423.         retVal = new XMLCh[1];
  1424.         if (retVal == NULL )
  1425.             return 0;
  1426.         retVal[0] = 0;
  1427.     }
  1428.     return retVal;
  1429. }
  1431. XMLCh* IconvFBSDLCPTranscoder::transcode(const char* const toTranscode,
  1432.                                          MemoryManager* const manager)
  1433. {
  1434.     if (!toTranscode)
  1435.         return 0;
  1437.     XMLCh* retVal = 0;
  1438.     if (*toTranscode) {
  1439.         const unsigned int wLent = calcRequiredSize(toTranscode);
  1440.         if (wLent == 0) {
  1441.             retVal = (XMLCh*) manager->allocate(sizeof(XMLCh));//new XMLCh[1];
  1442.             retVal[0] = 0;
  1443.             return retVal;
  1444.         }
  1446. #ifndef XML_USE_LIBICONV
  1448.         wchar_t       tmpWideCharArr[gTempBuffArraySize];
  1449.         wchar_t*      allocatedArray = 0;
  1450.         wchar_t*      wideCharBuf = 0;
  1452.         if (wLent >= gTempBuffArraySize)
  1453.             wideCharBuf = allocatedArray = (wchar_t*) manager->allocate
  1454.             (
  1455.                 (wLent + 1) * sizeof(wchar_t)
  1456.             );//new wchar_t[wLent + 1];
  1457.         else
  1458.             wideCharBuf = tmpWideCharArr;
  1460.         fbsd_mbstowcs(wideCharBuf, toTranscode, wLent);
  1461.         retVal = (XMLCh*) manager->allocate((wLent + 1) * sizeof(XMLCh));//new XMLCh[wLent + 1];
  1462.         if (retVal == NULL) {
  1463.             if (allocatedArray)
  1464.                 manager->deallocate(allocatedArray);//delete [] allocatedArray;
  1465.             return NULL;
  1466.         }
  1467.         for (unsigned int i = 0; i < wLent; i++)
  1468.             retVal[i] = (XMLCh) wideCharBuf[i];
  1469.         retVal[wLent] = 0x00;
  1470.         if (allocatedArray)
  1471.             manager->deallocate(allocatedArray);//delete [] allocatedArray;
  1473. #else /* XML_USE_LIBICONV */
  1475.         char    tmpWBuff[gTempBuffArraySize];
  1476.         char    *wideCharBuf = 0;
  1477.         char    *wBufPtr = 0;
  1478.         size_t  len = wLent * uChSize();
  1480.         retVal = (XMLCh*) manager->allocate((wLent + 1) * sizeof(XMLCh));//new XMLCh[wLent + 1];
  1481.         if (retVal == NULL)
  1482.             return NULL;
  1483.         if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
  1484.             if (len > gTempBuffArraySize) {
  1485.                 wBufPtr = (char*) manager->allocate(len * sizeof(char));//new char[len];
  1486.                 if (wBufPtr == NULL)
  1487.                     return 0;
  1488.                 wideCharBuf = wBufPtr;
  1489.             } else
  1490.                 wideCharBuf = tmpWBuff;
  1491.         } else
  1492.             wideCharBuf = (char *) retVal;
  1494.         size_t    flen = strlen(toTranscode);
  1495.         char    *ptr = wideCharBuf;
  1496.         size_t    rc = iconvFrom(toTranscode, &flen, &ptr, len);
  1497.         if (rc == (size_t) -1) {
  1498.             if (wBufPtr)
  1499.             manager->deallocate(wBufPtr);//delete [] wBufPtr;
  1500.             return NULL;
  1501.         }
  1502.         if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER)
  1503.             mbsToXML (wideCharBuf, wLent, retVal, wLent);
  1504.         if (wBufPtr)
  1505.             manager->deallocate(wBufPtr);//delete [] wBufPtr;
  1506.         retVal[wLent] = 0x00;
  1508. #endif /* !XML_USE_LIBICONV */
  1510.     }
  1511.     else {
  1512.         retVal = (XMLCh*) manager->allocate(sizeof(XMLCh));//new XMLCh[1];
  1513.         if (retVal == NULL )
  1514.             return 0;
  1515.         retVal[0] = 0;
  1516.     }
  1517.     return retVal;
  1518. }
  1521. bool IconvFBSDLCPTranscoder::transcode(const   char* const    toTranscode
  1522.                        ,       XMLCh* const    toFill
  1523.                        , const unsigned int    maxChars)
  1524. {
  1525.     // Check for a couple of psycho corner cases
  1526.     if (!toTranscode || !maxChars)
  1527.     {
  1528.         toFill[0] = 0;
  1529.         return true;
  1530.     }
  1532.     if (!*toTranscode)
  1533.     {
  1534.         toFill[0] = 0;
  1535.         return true;
  1536.     }
  1538.     size_t wLent = calcRequiredSize(toTranscode);
  1539.     if (wLent > maxChars)
  1540.         wLent = maxChars;
  1542. #ifndef XML_USE_LIBICONV
  1544.     wchar_t       tmpWideCharArr[gTempBuffArraySize];
  1545.     wchar_t*      allocatedArray = 0;
  1546.     wchar_t*      wideCharBuf = 0;
  1548.     if (maxChars >= gTempBuffArraySize)
  1549.         wideCharBuf = allocatedArray = (wchar_t*) XMLPlatformUtils::fgMemoryManager->allocate
  1550.         (
  1551.             (wLent + 1) * sizeof(wchar_t)
  1552.         );//new wchar_t[wLent + 1];
  1553.     else
  1554.         wideCharBuf = tmpWideCharArr;
  1556.     if (fbsd_mbstowcs(wideCharBuf, toTranscode, wLent) == -1) {
  1557.         if (allocatedArray)
  1558.             XMLPlatformUtils::fgMemoryManager->deallocate(allocatedArray);//delete [] allocatedArray;
  1559.         return false;
  1560.     }
  1561.     for (unsigned int i = 0; i < wLent; i++)
  1562.         toFill[i] = (XMLCh) wideCharBuf[i];
  1563.     if (allocatedArray)
  1564.     XMLPlatformUtils::fgMemoryManager->deallocate(allocatedArray);//delete [] allocatedArray;
  1566. #else /* XML_USE_LIBICONV */
  1568.     char    tmpWBuff[gTempBuffArraySize];
  1569.     char    *wideCharBuf = 0;
  1570.     char    *wBufPtr = 0;
  1571.     size_t    len = wLent * uChSize();
  1573.     if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
  1574.     if (len > gTempBuffArraySize) {
  1575.         wBufPtr = (char*) XMLPlatformUtils::fgMemoryManager->allocate
  1576.         (
  1577.             len * sizeof(char)
  1578.         );//new char[len];
  1579.         if (wBufPtr == NULL)
  1580.         return 0;
  1581.         wideCharBuf = wBufPtr;
  1582.     } else
  1583.         wideCharBuf = tmpWBuff;
  1584.     } else
  1585.     wideCharBuf = (char *) toFill;
  1587.     size_t    flen = strlen(toTranscode); // wLent;
  1588.     char    *ptr = wideCharBuf;
  1589.     size_t    rc = iconvFrom(toTranscode, &flen, &ptr, len);
  1590.     if (rc == (size_t)-1) {
  1591.         if (wBufPtr)
  1592.             XMLPlatformUtils::fgMemoryManager->deallocate(wBufPtr);//delete [] wBufPtr;
  1593.         return false;
  1594.     }
  1596.     if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER)
  1597.     mbsToXML (wideCharBuf, wLent, toFill, wLent);
  1598.     if (wBufPtr)
  1599.         XMLPlatformUtils::fgMemoryManager->deallocate(wBufPtr);//delete [] wBufPtr;
  1601. #endif /* !XML_USE_LIBICONV */
  1603.     toFill[wLent] = 0x00;
  1604.     return true;
  1605. }
  1608. // ---------------------------------------------------------------------------
  1609. //  IconvFBSDLCPTranscoder: Constructors and Destructor
  1610. // ---------------------------------------------------------------------------
  1612. #ifdef XML_USE_LIBICONV
  1614. IconvFBSDLCPTranscoder::IconvFBSDLCPTranscoder (iconv_t        cd_from,
  1615.                         iconv_t        cd_to,
  1616.                         size_t        uchsize,
  1617.                         unsigned int    ubo)
  1618.     : IconvFBSDCD (cd_from, cd_to, uchsize, ubo)
  1619. {
  1620. }
  1622. #endif /* XML_USE_LIBICONV */
  1625. #ifndef XML_USE_LIBICONV
  1627. IconvFBSDLCPTranscoder::IconvFBSDLCPTranscoder()
  1628. {
  1629. }
  1631. #endif /* !XML_USE_LIBICONV */
  1633. IconvFBSDLCPTranscoder::~IconvFBSDLCPTranscoder()
  1634. {
  1635. }
  1638. #ifdef XML_USE_LIBICONV
  1640. // ---------------------------------------------------------------------------
  1641. //  IconvFBSDTranscoder: Constructors and Destructor
  1642. // ---------------------------------------------------------------------------
  1643. IconvFBSDTranscoder::IconvFBSDTranscoder (const    XMLCh* const    encodingName
  1644.                       , const unsigned int    blockSize
  1645.                       ,    iconv_t        cd_from
  1646.                       ,    iconv_t        cd_to
  1647.                       ,    size_t        uchsize
  1648.                       ,    unsigned int    ubo
  1649.                       , MemoryManager* const manager
  1650.     )
  1651.     : XMLTranscoder(encodingName, blockSize, manager)
  1652.     , IconvFBSDCD (cd_from, cd_to, uchsize, ubo)
  1653. {
  1654. }
  1656. IconvFBSDTranscoder::~IconvFBSDTranscoder()
  1657. {
  1658.     ICONV_LOCK;
  1659.     if (cdTo() != (iconv_t)-1) {
  1660.         iconv_close (cdTo());
  1661.         setCDTo ((iconv_t)-1);
  1662.     }
  1663.     if (cdFrom() != (iconv_t)-1) {
  1664.         iconv_close (cdFrom());
  1665.         setCDFrom ((iconv_t)-1);
  1666.     }
  1667. }
  1669. // ---------------------------------------------------------------------------
  1670. //  IconvFBSDTranscoder: Implementation of the virtual transcoder API
  1671. // ---------------------------------------------------------------------------
  1672. unsigned int    IconvFBSDTranscoder::transcodeFrom
  1673. (
  1674.     const   XMLByte* const          srcData
  1675.     , const unsigned int            srcCount
  1676.     ,       XMLCh* const            toFill
  1677.     , const unsigned int            maxChars
  1678.     ,       unsigned int&           bytesEaten
  1679.     ,       unsigned char* const    charSizes )
  1680. {
  1681.     // Transcode TO XMLCh
  1682.     const char*  startSrc = (const char*) srcData;
  1683.     const char*  endSrc = (const char*) srcData + srcCount;
  1685.     char    tmpWBuff[gTempBuffArraySize];
  1686.     char    *startTarget = 0;
  1687.     char    *wBufPtr = 0;
  1688.     size_t    len = maxChars * uChSize();
  1690.     if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
  1691.         if (len > gTempBuffArraySize) {
  1692.             wBufPtr = (char*) getMemoryManager()->allocate
  1693.             (
  1694.                 len * sizeof(char)
  1695.             );//new char[len];
  1696.             if (wBufPtr == NULL)
  1697.             return 0;
  1698.             startTarget = wBufPtr;
  1699.         } else
  1700.             startTarget = tmpWBuff;
  1701.     } else
  1702.     startTarget = (char *) toFill;
  1704.     // Do character-by-character transcoding
  1705.     char    *orgTarget = startTarget;
  1706.     size_t    srcLen = srcCount;
  1707.     size_t    prevSrcLen = srcLen;
  1708.     unsigned int toReturn = 0;
  1709.     bytesEaten = 0;
  1710.     for (size_t cnt = 0; cnt < maxChars && srcLen; cnt++) {
  1711.         size_t    rc = iconvFrom(startSrc, &srcLen, &orgTarget, uChSize());
  1712.         if (rc == (size_t)-1) {
  1713.             if (errno != E2BIG || prevSrcLen == srcLen) {
  1714.                 if (wBufPtr)
  1715.                     getMemoryManager()->deallocate(wBufPtr);//delete [] wBufPtr;
  1716.                 ThrowXML(TranscodingException, XMLExcepts::Trans_BadSrcSeq);
  1717.             }
  1718.         }
  1719.         charSizes[cnt] = prevSrcLen - srcLen;
  1720.         prevSrcLen = srcLen;
  1721.         bytesEaten += charSizes[cnt];
  1722.         startSrc = endSrc - srcLen;
  1723.         toReturn++;
  1724.     }
  1725.     if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER)
  1726.         mbsToXML (startTarget, toReturn, toFill, toReturn);
  1727.     if (wBufPtr)
  1728.         getMemoryManager()->deallocate(wBufPtr);//delete [] wBufPtr;
  1729.     return toReturn;
  1730. }
  1732. unsigned int    IconvFBSDTranscoder::transcodeTo
  1733. (
  1734.     const   XMLCh* const    srcData
  1735.     , const unsigned int    srcCount
  1736.     ,       XMLByte* const    toFill
  1737.     , const unsigned int    maxBytes
  1738.     ,       unsigned int&    charsEaten
  1739.     , const UnRepOpts        options )
  1740. {
  1741.     // Transcode FROM XMLCh
  1742.     char    tmpWBuff[gTempBuffArraySize];
  1743.     char    *startSrc = tmpWBuff;
  1744.     char    *wBufPtr = 0;
  1745.     size_t    len = srcCount * uChSize();
  1747.     if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
  1748.         if (len > gTempBuffArraySize) {
  1749.             wBufPtr = (char*) getMemoryManager()->allocate
  1750.             (
  1751.                 len * sizeof(char)
  1752.             );//new char[len];
  1753.             if (wBufPtr == NULL)
  1754.                 return 0;
  1755.             startSrc = wBufPtr;
  1756.         } else
  1757.             startSrc = tmpWBuff;
  1758.         xmlToMbs (srcData, srcCount, startSrc, srcCount);
  1759.     } else
  1760.         startSrc = (char *) srcData;
  1762.     char*    startTarget = (char *) toFill;
  1763.     size_t    srcLen = len;
  1764.     size_t    rc = iconvTo (startSrc, &srcLen, &startTarget, maxBytes);
  1765.     if (rc == (size_t)-1 && errno != E2BIG) {
  1766.         if (wBufPtr)
  1767.             getMemoryManager()->deallocate(wBufPtr);//delete [] wBufPtr;
  1768.         ThrowXML(TranscodingException, XMLExcepts::Trans_BadSrcSeq);
  1769.     }
  1770.     charsEaten = srcCount - srcLen / uChSize();
  1771.     if (wBufPtr)
  1772.         getMemoryManager()->deallocate(wBufPtr);//delete [] wBufPtr;
  1773.     return startTarget - (char *)toFill;
  1774. }
  1776. bool        IconvFBSDTranscoder::canTranscodeTo
  1777. (
  1778.     const unsigned int toCheck
  1779. )   const
  1780. {
  1781.     //
  1782.     //  If the passed value is really a surrogate embedded together, then
  1783.     //  we need to break it out into its two chars. Else just one.
  1784.     //
  1785.     char        srcBuf[2 * uChSize()];
  1786.     unsigned int    srcCount = 1;
  1787.     if (toCheck & 0xFFFF0000) {
  1788.         XMLCh    ch1 = (toCheck >> 10) + 0xD800;
  1789.         XMLCh    ch2 = toCheck & 0x3FF + 0xDC00;
  1790.         xmlToMbs(&ch1, 1, srcBuf, 1);
  1791.         xmlToMbs(&ch2, 1, srcBuf + uChSize(), 1);
  1792.         srcCount++;
  1793.     } else
  1794.         xmlToMbs((const XMLCh*) &toCheck, 1, srcBuf, 1);
  1795.     size_t    len = srcCount * uChSize();
  1796.     char    tmpBuf[64];
  1797.     char*    pTmpBuf = tmpBuf;
  1799.     size_t    rc = iconvTo( srcBuf, &len, &pTmpBuf, 64);
  1800.     return (rc != (size_t)-1) && (len == 0);
  1801. }
  1803. #endif /* XML_USE_LIBICONV */
  1805. XERCES_CPP_NAMESPACE_END