tng 2002/08/19 12:38:18
Modified: c/src/xercesc configure configure.in runConfigure
c/src/xercesc/util Makefile.in
c/src/xercesc/util/Platforms/Linux LinuxPlatformUtils.cpp
Added: c/src/xercesc/util/Transcoders/IconvGNU
IconvGNUTransService.cpp IconvGNUTransService.hpp
Makefile.in
Log:
[Bug 11771] Linux specific IconvGNU transcoder. Patch from Vasily Tchekalkin.
Revision Changes Path
1.8 +2 -0 xml-xerces/c/src/xercesc/configure
Index: configure
===================================================================
RCS file: /home/cvs/xml-xerces/c/src/xercesc/configure,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -r1.7 -r1.8
--- configure 19 Aug 2002 18:35:56 -0000 1.7
+++ configure 19 Aug 2002 19:38:17 -0000 1.8
@@ -1445,6 +1445,7 @@
util/Transcoders/Iconv390/Makefile \
util/Transcoders/Iconv400/Makefile \
util/Transcoders/IconvFBSD/Makefile \
+util/Transcoders/IconvGNU/Makefile \
util/Transcoders/MacOSUnicodeConverter/Makefile \
util/Platforms/Makefile \
util/Platforms/Solaris/Makefile \
@@ -1595,6 +1596,7 @@
util/Transcoders/Iconv390/Makefile \
util/Transcoders/Iconv400/Makefile \
util/Transcoders/IconvFBSD/Makefile \
+util/Transcoders/IconvGNU/Makefile \
util/Transcoders/MacOSUnicodeConverter/Makefile \
util/Platforms/Makefile \
util/Platforms/Solaris/Makefile \
1.10 +1 -0 xml-xerces/c/src/xercesc/configure.in
Index: configure.in
===================================================================
RCS file: /home/cvs/xml-xerces/c/src/xercesc/configure.in,v
retrieving revision 1.9
retrieving revision 1.10
diff -u -r1.9 -r1.10
--- configure.in 19 Aug 2002 18:35:56 -0000 1.9
+++ configure.in 19 Aug 2002 19:38:17 -0000 1.10
@@ -115,6 +115,7 @@
util/Transcoders/Iconv390/Makefile \
util/Transcoders/Iconv400/Makefile \
util/Transcoders/IconvFBSD/Makefile \
+util/Transcoders/IconvGNU/Makefile \
util/Transcoders/MacOSUnicodeConverter/Makefile \
util/Platforms/Makefile \
util/Platforms/Solaris/Makefile \
1.17 +5 -2 xml-xerces/c/src/xercesc/runConfigure
Index: runConfigure
===================================================================
RCS file: /home/cvs/xml-xerces/c/src/xercesc/runConfigure,v
retrieving revision 1.16
retrieving revision 1.17
diff -u -r1.16 -r1.17
--- runConfigure 19 Aug 2002 18:35:56 -0000 1.16
+++ runConfigure 19 Aug 2002 19:38:17 -0000 1.17
@@ -92,7 +92,7 @@
echo " -d (specifies that you want to build debug version)"
echo " -m <message loader> can be 'inmem', 'icu', 'MsgFile' or 'iconv'"
echo " -n <net accessor> can be 'fileonly', 'libwww', 'socket' or
'native'"
- echo " -t <transcoder> can be 'icu', 'Iconv400', 'Iconv390', 'IconvFBSD'
or 'native'"
+ echo " -t <transcoder> can be 'icu', 'Iconv400', 'Iconv390', 'IconvFBSD',
'IconvGNU' or 'native'"
echo " -r <thread option> can be 'pthread' or 'dce' (AIX, HP-11, and
Solaris) or 'sproc' (IRIX) or 'none'"
echo " -b <bitsToBuild> (accepts '64', '32')"
echo " -l <extra linker options>"
@@ -444,6 +444,9 @@
IconvFBSD)
TRANSCODER=IconvFBSD ;
transcodingDefines="-DXML_USE_LIBICONV -I/usr/local/include" ;;
+ IconvGNU)
+ TRANSCODER=IconvGNU ;
+ transcodingDefines="-DXML_USE_GNU_TRANSCODER -I/usr/local/include" ;;
native)
if test $platform = "cygwin"; then
TRANSCODER=Cygwin ;
1.13 +8 -1 xml-xerces/c/src/xercesc/util/Makefile.in
Index: Makefile.in
===================================================================
RCS file: /home/cvs/xml-xerces/c/src/xercesc/util/Makefile.in,v
retrieving revision 1.12
retrieving revision 1.13
diff -u -r1.12 -r1.13
--- Makefile.in 19 Aug 2002 18:35:56 -0000 1.12
+++ Makefile.in 19 Aug 2002 19:38:17 -0000 1.13
@@ -55,8 +55,11 @@
#
#
# $Log$
+# Revision 1.13 2002/08/19 19:38:17 tng
+# [Bug 11771] Linux specific IconvGNU transcoder. Patch from Vasily Tchekalkin.
+#
# Revision 1.12 2002/08/19 18:35:56 tng
-# [Bug 6467] Installing Xerces C++ on cygwin environment.
+# [Bug 6467] Installing Xerces C++ on cygwin environment. Patch from Derek Harmon.
#
# Revision 1.11 2002/07/26 16:49:27 tng
# [Bug 2681] Can't build with gcc/g++ not named 'gcc'/'g++'. Patch from Jonathan
Lennox.
@@ -326,7 +329,11 @@
ifeq (${TRANSCODER},Cygwin)
TRANSCODERMODULE=Cygwin
else
- TRANSCODERMODULE=Iconv
+ ifeq (${TRANSCODER},IconvGNU)
+ TRANSCODERMODULE=IconvGNU
+ else
+ TRANSCODERMODULE=Iconv
+ endif
endif
endif
endif
1.7 +9 -2
xml-xerces/c/src/xercesc/util/Platforms/Linux/LinuxPlatformUtils.cpp
Index: LinuxPlatformUtils.cpp
===================================================================
RCS file:
/home/cvs/xml-xerces/c/src/xercesc/util/Platforms/Linux/LinuxPlatformUtils.cpp,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -r1.6 -r1.7
--- LinuxPlatformUtils.cpp 15 Jul 2002 21:53:04 -0000 1.6
+++ LinuxPlatformUtils.cpp 19 Aug 2002 19:38:17 -0000 1.7
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.7 2002/08/19 19:38:17 tng
+ * [Bug 11771] Linux specific IconvGNU transcoder. Patch from Vasily Tchekalkin.
+ *
* Revision 1.6 2002/07/15 21:53:04 peiyongz
* CouldNotWriteToFile
*
@@ -189,6 +192,8 @@
#if defined(XML_USE_ICU_TRANSCODER)
#include <xercesc/util/Transcoders/ICU/ICUTransService.hpp>
+#elif defined (XML_USE_GNU_TRANSCODER)
+ #include <xercesc/util/Transcoders/IconvGNU/IconvGNUTransService.hpp>
#else
// Use native transcoder. Same as -DXML_USE_NATIVE_TRANSCODER
#include <xercesc/util/Transcoders/Iconv/IconvTransService.hpp>
@@ -262,9 +267,11 @@
// Use ICU transcoding services.
// same as -DXML_USE_ICU_MESSAGELOADER
return new ICUTransService;
+#elif defined (XML_USE_GNU_TRANSCODER)
+ return new IconvGNUTransService;
#else
// Use native transcoding services.
- // same as -DXML_USE_INMEM_MESSAGELOADER
+ // same as -DXML_USE_NATIVE_TRANSCODER
return new IconvTransService;
#endif
@@ -401,7 +408,7 @@
void
XMLPlatformUtils::writeBufferToFile( FileHandle const theFile
, long toWrite
- , const XMLByte* const toFlush)
+ , const XMLByte* const toFlush)
{
if (!theFile ||
(toWrite <= 0 ) ||
1.1
xml-xerces/c/src/xercesc/util/Transcoders/IconvGNU/IconvGNUTransService.cpp
Index: IconvGNUTransService.cpp
===================================================================
/*
* The Apache Software License, Version 1.1
*
* Copyright (c) 2002 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Xerces" and "Apache Software Foundation" must
* not be used to endorse or promote products derived from this
* software without prior written permission. For written
* permission, please contact apache\@apache.org.
*
* 5. Products derived from this software may not be called "Apache",
* nor may "Apache" appear in their name, without prior written
* permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation, and was
* originally based on software copyright (c) 2001, International
* Business Machines, Inc., http://www.ibm.com . For more information
* on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*/
/*
* $Log: IconvGNUTransService.cpp,v $
* Revision 1.1 2002/08/19 19:38:18 tng
* [Bug 11771] Linux specific IconvGNU transcoder. Patch from Vasily Tchekalkin.
*
*/
// ---------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------
#include <ctype.h>
#include <locale.h>
#include <iconv.h>
#include <errno.h>
#include <endian.h>
// ---------------------------------------------------------------------------
// Description of encoding schemas, supported by iconv()
// ---------------------------------------------------------------------------
typedef struct __IconvGNUEncoding {
const char* fSchema; // schema name
size_t fUChSize; // size of the character
unsigned int fUBO; // byte order, relative to the host
} IconvGNUEncoding;
static const IconvGNUEncoding gIconvGNUEncodings[] = {
{ "UCS-2LE", 2, LITTLE_ENDIAN },
{ "ucs-2-internal", 2, LITTLE_ENDIAN },
{ NULL, 0, 0 }
};
//--------------------------------------------------
// Macro-definitions to translate "native unicode"
// characters <-> XMLCh with different host byte order
// and encoding schemas.
# if BYTE_ORDER == LITTLE_ENDIAN
# define IXMLCh2WC16(x,w) \
*(w) = ((*(x)) >> 8) & 0xFF; \
*((w)+1) = (*(x)) & 0xFF
# define IWC162XMLCh(w,x) *(x) = ((*(w)) << 8) | (*((w)+1))
# define XMLCh2WC16(x,w) \
*(w) = (*(x)) & 0xFF; \
*((w)+1) = ((*(x)) >> 8) & 0xFF
# define WC162XMLCh(w,x) *(x) = ((*((w)+1)) << 8) | (*(w))
# define IXMLCh2WC32(x,w) \
*(w) = ((*(x)) >> 24) & 0xFF; \
*((w)+1) = ((*(x)) >> 16) & 0xFF; \
*((w)+2) = ((*(x)) >> 8) & 0xFF; \
*((w)+3) = (*(x)) & 0xFF
# define IWC322XMLCh(w,x) \
*(x) = ((*(w)) << 24) | ((*((w)+1)) << 16) | \
((*((w)+2)) << 8) | (*((w)+3))
# define XMLCh2WC32(x,w) \
*((w)+3) = ((*(x)) >> 24) & 0xFF; \
*((w)+2) = ((*(x)) >> 16) & 0xFF; \
*((w)+1) = ((*(x)) >> 8) & 0xFF; \
*(w) = (*(x)) & 0xFF
# define WC322XMLCh(w,x) \
*(x) = ((*((w)+3)) << 24) | ((*((w)+2)) << 16) | \
((*((w)+1)) << 8) | (*(w))
# else /* BYTE_ORDER != LITTLE_ENDIAN */
# define XMLCh2WC16(x,w) \
*(w) = ((*(x)) >> 8) & 0xFF; \
*((w)+1) = (*(x)) & 0xFF
# define WC162XMLCh(w,x) *(x) = ((*(w)) << 8) | (*((w)+1))
# define IXMLCh2WC16(x,w) \
*(w) = (*(x)) & 0xFF; \
*((w)+1) = ((*(x)) >> 8) & 0xFF
# define IWC162XMLCh(w,x) *(x) = ((*((w)+1)) << 8) | (*(w))
# define XMLCh2WC32(x,w) \
*(w) = ((*(x)) >> 24) & 0xFF; \
*((w)+1) = ((*(x)) >> 16) & 0xFF; \
*((w)+2) = ((*(x)) >> 8) & 0xFF; \
*((w)+3) = (*(x)) & 0xFF
# define WC322XMLCh(w,x) \
*(x) = ((*(w)) << 24) | ((*((w)+1)) << 16) | \
((*((w)+2)) << 8) | (*((w)+3))
# define IXMLCh2WC32(x,w) \
*((w)+3) = ((*(x)) >> 24) & 0xFF; \
*((w)+2) = ((*(x)) >> 16) & 0xFF; \
*((w)+1) = ((*(x)) >> 8) & 0xFF; \
*(w) = (*(x)) & 0xFF
# define IWC322XMLCh(w,x) \
*(x) = ((*((w)+3)) << 24) | ((*((w)+2)) << 16) | \
((*((w)+1)) << 8) | (*(w))
# endif /* BYTE_ORDER == LITTLE_ENDIAN */
#include <wchar.h>
#include <xercesc/util/XMLString.hpp>
#include <xercesc/util/XMLUniDefs.hpp>
#include <xercesc/util/XMLUni.hpp>
#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/util/TranscodingException.hpp>
#include "IconvGNUTransService.hpp"
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
// ---------------------------------------------------------------------------
// Local, const data
// ---------------------------------------------------------------------------
static const unsigned int gTempBuffArraySize = 4096;
static const XMLCh gMyServiceId[] =
{
chLatin_I, chLatin_C, chLatin_o, chLatin_n, chLatin_v, chNull
};
// ---------------------------------------------------------------------------
// Local methods
// ---------------------------------------------------------------------------
static unsigned int getWideCharLength(const XMLCh* const src)
{
if (!src)
return 0;
unsigned int len = 0;
const XMLCh* pTmp = src;
while (*pTmp++)
len++;
return len;
}
#if !defined(APP_NO_THREADS)
#include <xercesc/util/Mutexes.hpp>
// Iconv() access syncronization point
static XMLMutex *gIconvMutex = NULL;
# define ICONV_LOCK XMLMutexLock lockConverter(gIconvMutex);
#else /* APP_NO_THREADS */
# define ICONV_LOCK
#endif /* !APP_NO_THREADS */
//----------------------------------------------------------------------------
// There is implementation of the libiconv for FreeBSD (available through the
// ports collection). The following is a wrapper around the iconv().
//----------------------------------------------------------------------------
IconvGNUWrapper::IconvGNUWrapper ()
: fUChSize(0), fUBO(LITTLE_ENDIAN),
fCDTo((iconv_t)-1), fCDFrom((iconv_t)-1)
{
}
IconvGNUWrapper::IconvGNUWrapper ( iconv_t cd_from,
iconv_t cd_to,
size_t uchsize,
unsigned int ubo )
: fUChSize(uchsize), fUBO(ubo),
fCDTo(cd_to), fCDFrom(cd_from)
{
if (fCDFrom == (iconv_t) -1 || fCDTo == (iconv_t) -1) {
XMLPlatformUtils::panic (XMLPlatformUtils::Panic_NoTransService);
}
}
IconvGNUWrapper::~IconvGNUWrapper()
{
}
// Convert "native unicode" character into XMLCh
void IconvGNUWrapper::mbcToXMLCh (const char *mbc, XMLCh *toRet) const
{
if (fUBO == LITTLE_ENDIAN) {
if (fUChSize == sizeof(XMLCh))
*toRet = *((XMLCh*) mbc);
else if (fUChSize == 2) {
WC162XMLCh( mbc, toRet );
} else {
WC322XMLCh( mbc, toRet );
}
} else {
if (fUChSize == 2) {
IWC162XMLCh( mbc, toRet );
} else {
IWC322XMLCh( mbc, toRet );
}
}
}
// Convert XMLCh into "native unicode" character
void IconvGNUWrapper::xmlChToMbc (XMLCh xch, char *mbc) const
{
if (fUBO == LITTLE_ENDIAN) {
if (fUChSize == sizeof(XMLCh)) {
memcpy (mbc, &xch, fUChSize);
return;
}
if (fUChSize == 2) {
XMLCh2WC16( &xch, mbc );
} else {
XMLCh2WC32( &xch, mbc );
}
} else {
if (fUChSize == 2) {
IXMLCh2WC16( &xch, mbc );
} else {
IXMLCh2WC32( &xch, mbc );
}
}
}
// Return uppercase equivalent for XMLCh
XMLCh IconvGNUWrapper::toUpper (const XMLCh ch) const
{
if (ch <= 0x7F)
return toupper(ch);
char wcbuf[fUChSize * 2];
xmlChToMbc (ch, wcbuf);
char tmpArr[4];
char* ptr = wcbuf;
size_t len = fUChSize;
char *pTmpArr = tmpArr;
size_t bLen = 2;
ICONV_LOCK;
if (::iconv (fCDTo, &ptr, &len,
&pTmpArr, &bLen) == (size_t) -1)
return 0;
tmpArr[1] = toupper (*((unsigned char *)tmpArr));
*tmpArr = tmpArr[1];
len = 1;
pTmpArr = wcbuf;
bLen = fUChSize;
ptr = tmpArr;
if (::iconv (fCDFrom, &ptr, &len,
&pTmpArr, &bLen) == (size_t) -1)
return 0;
mbcToXMLCh (wcbuf, (XMLCh*) &ch);
return ch;
}
// Return lowercase equivalent for XMLCh
XMLCh IconvGNUWrapper::toLower (const XMLCh ch) const
{
if (ch <= 0x7F)
return tolower(ch);
char wcbuf[fUChSize * 2];
xmlChToMbc (ch, wcbuf);
char tmpArr[4];
char* ptr = wcbuf;
size_t len = fUChSize;
char *pTmpArr = tmpArr;
size_t bLen = 2;
ICONV_LOCK;
if (::iconv (fCDTo, &ptr, &len,
&pTmpArr, &bLen) == (size_t) -1)
return 0;
tmpArr[1] = tolower (*((unsigned char*)tmpArr));
*tmpArr = tmpArr[1];
len = 1;
pTmpArr = wcbuf;
bLen = fUChSize;
ptr = tmpArr;
if (::iconv (fCDFrom, &ptr, &len,
&pTmpArr, &bLen) == (size_t) -1)
return 0;
mbcToXMLCh (wcbuf, (XMLCh*) &ch);
return ch;
}
// Check if passed characters belongs to the :space: class
bool IconvGNUWrapper::isSpace(const XMLCh toCheck) const
{
if (toCheck <= 0x7F)
return isspace(toCheck);
char wcbuf[fUChSize * 2];
char tmpArr[4];
xmlChToMbc (toCheck, wcbuf);
char* ptr = wcbuf;
size_t len = fUChSize;
char *pTmpArr = tmpArr;
size_t bLen = 2;
{
ICONV_LOCK;
if (::iconv (fCDTo, &ptr, &len,
&pTmpArr, &bLen) == (size_t) -1)
return 0;
}
return isspace(*tmpArr);
}
// Fill array of XMLCh characters with data, supplyed in the array
// of "native unicode" characters.
XMLCh* IconvGNUWrapper::mbsToXML
(
const char* mbs_str
, size_t mbs_cnt
, XMLCh* xml_str
, size_t xml_cnt
) const
{
if (mbs_str == NULL || mbs_cnt == 0 || xml_str == NULL || xml_cnt == 0)
return NULL;
size_t cnt = (mbs_cnt < xml_cnt) ? mbs_cnt : xml_cnt;
if (fUBO == LITTLE_ENDIAN) {
if (fUChSize == sizeof(XMLCh)) {
// null-transformation
memcpy (xml_str, mbs_str, fUChSize * cnt);
return xml_str;
}
if (fUChSize == 2)
for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize) {
WC162XMLCh( mbs_str, xml_str + i);
}
else
for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize) {
WC322XMLCh( mbs_str, xml_str + i );
}
} else {
if (fUChSize == 2)
for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize) {
IWC162XMLCh( mbs_str, xml_str + i );
}
else
for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize) {
IWC322XMLCh( mbs_str, xml_str + i );
}
}
return xml_str;
}
// Fill array of "native unicode" characters with data, supplyed
// in the array of XMLCh characters.
char* IconvGNUWrapper::xmlToMbs
(
const XMLCh* xml_str
, size_t xml_cnt
, char* mbs_str
, size_t mbs_cnt
) const
{
if (mbs_str == NULL || mbs_cnt == 0 || xml_str == NULL || xml_cnt == 0)
return NULL;
size_t cnt = (mbs_cnt < xml_cnt) ? mbs_cnt : xml_cnt;
char *toReturn = mbs_str;
if (fUBO == LITTLE_ENDIAN) {
if (fUChSize == sizeof(XMLCh)) {
// null-transformation
memcpy (mbs_str, xml_str, fUChSize * cnt);
return toReturn;
}
if (fUChSize == 2)
for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize, xml_str++) {
XMLCh2WC16( xml_str, mbs_str );
}
else
for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize, xml_str++) {
XMLCh2WC32( xml_str, mbs_str );
}
} else {
if (fUChSize == 2)
for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize, xml_str++) {
IXMLCh2WC16( xml_str, mbs_str );
}
else
for (size_t i = 0; i < cnt; i++, mbs_str += fUChSize, xml_str++) {
IXMLCh2WC32( xml_str, mbs_str );
}
}
return toReturn;
}
size_t IconvGNUWrapper::iconvFrom ( const char *fromPtr,
size_t *fromLen,
char **toPtr,
size_t toLen ) const
{
ICONV_LOCK;
char ** tmpPtr = (char**)&fromPtr;
return ::iconv (fCDFrom, tmpPtr, fromLen, toPtr, &toLen);
}
size_t IconvGNUWrapper::iconvTo ( const char *fromPtr,
size_t *fromLen,
char **toPtr,
size_t toLen ) const
{
ICONV_LOCK;
char ** tmpPtr = (char**)&fromPtr;
return ::iconv (fCDTo, tmpPtr, fromLen, toPtr, &toLen);
}
// ---------------------------------------------------------------------------
// IconvGNUTransService: Constructors and Destructor
// ---------------------------------------------------------------------------
IconvGNUTransService::IconvGNUTransService()
: IconvGNUWrapper(), fUnicodeCP(0)
{
#if !defined(APP_NO_THREADS)
// Create global lock object
if (gIconvMutex == NULL) {
gIconvMutex = new XMLMutex;
if (gIconvMutex == NULL)
XMLPlatformUtils::panic (XMLPlatformUtils::Panic_NoTransService);
}
#endif
// Try to obtain local (host) characterset through the environment
char* fLocalCP = setlocale (LC_CTYPE, "");
if (fLocalCP == NULL)
fLocalCP = "iso-8859-1"; // fallback locale
else {
char *ptr = strchr (fLocalCP, '.');
if (ptr == NULL)
fLocalCP = "iso-8859-1"; // fallback locale
else
fLocalCP = ptr + 1;
}
// Select the native unicode characters encoding schema
const IconvGNUEncoding *eptr;
// first - try to use the schema with character size, equil to XMLCh
for (eptr = gIconvGNUEncodings; eptr->fSchema; eptr++) {
if (eptr->fUChSize != sizeof(XMLCh))
continue;
ICONV_LOCK;
// try to create conversion descriptor
iconv_t cd_to = iconv_open(fLocalCP, eptr->fSchema);
if (cd_to == (iconv_t)-1)
continue;
iconv_t cd_from = iconv_open(eptr->fSchema, fLocalCP);
if (cd_to == (iconv_t)-1) {
iconv_close (cd_to);
continue;
}
// got it
setUChSize(eptr->fUChSize);
setUBO(eptr->fUBO);
setCDTo(cd_to);
setCDFrom(cd_from);
fUnicodeCP = eptr->fSchema;
break;
}
if (fUnicodeCP == NULL)
// try to use any known schema
for (eptr = gIconvGNUEncodings; eptr->fSchema; eptr++) {
// try to create conversion descriptor
ICONV_LOCK;
iconv_t cd_to = iconv_open(fLocalCP, eptr->fSchema);
if (cd_to == (iconv_t)-1)
continue;
iconv_t cd_from = iconv_open(eptr->fSchema, fLocalCP);
if (cd_to == (iconv_t)-1) {
iconv_close (cd_to);
continue;
}
// got it
setUChSize(eptr->fUChSize);
setUBO(eptr->fUBO);
setCDTo(cd_to);
setCDFrom(cd_from);
fUnicodeCP = eptr->fSchema;
break;
}
if (fUnicodeCP == NULL || cdTo() == (iconv_t)-1 || cdFrom() == (iconv_t)-1)
XMLPlatformUtils::panic (XMLPlatformUtils::Panic_NoTransService);
}
IconvGNUTransService::~IconvGNUTransService()
{
if (cdTo() != (iconv_t) -1) {
iconv_close (cdTo());
setCDTo ((iconv_t)-1);
}
if (cdFrom() != (iconv_t) -1) {
iconv_close (cdFrom());
setCDFrom ((iconv_t)-1);
}
}
// ---------------------------------------------------------------------------
// IconvGNUTransService: The virtual transcoding service API
// ---------------------------------------------------------------------------
int IconvGNUTransService::compareIString(const XMLCh* const comp1
, const XMLCh* const comp2)
{
const XMLCh* cptr1 = comp1;
const XMLCh* cptr2 = comp2;
XMLCh c1 = toUpper(*cptr1);
XMLCh c2 = toUpper(*cptr2);
while ( (*cptr1 != 0) && (*cptr2 != 0) ) {
if (c1 != c2)
break;
c1 = toUpper(*(++cptr1));
c2 = toUpper(*(++cptr2));
}
return (int) ( c1 - c2 );
}
int IconvGNUTransService::compareNIString(const XMLCh* const comp1
, const XMLCh* const comp2
, const unsigned int maxChars)
{
unsigned int n = 0;
const XMLCh* cptr1 = comp1;
const XMLCh* cptr2 = comp2;
while (true && maxChars)
{
XMLCh c1 = toUpper(*cptr1);
XMLCh c2 = toUpper(*cptr2);
if (c1 != c2)
return (int) (c1 - c2);
// If either ended, then both ended, so equal
if (!*cptr1 || !*cptr2)
break;
cptr1++;
cptr2++;
// Bump the count of chars done. If it equals the count then we
// are equal for the requested count, so break out and return
// equal.
n++;
if (n == maxChars)
break;
}
return 0;
}
const XMLCh* IconvGNUTransService::getId() const
{
return gMyServiceId;
}
bool IconvGNUTransService::isSpace(const XMLCh toCheck) const
{
return IconvGNUWrapper::isSpace(toCheck);
}
XMLLCPTranscoder* IconvGNUTransService::makeNewLCPTranscoder()
{
return new IconvGNULCPTranscoder (cdFrom(), cdTo(), uChSize(), UBO());
}
bool IconvGNUTransService::supportsSrcOfs() const
{
return true;
}
// ---------------------------------------------------------------------------
// IconvGNUTransService: The protected virtual transcoding service API
// ---------------------------------------------------------------------------
XMLTranscoder*
IconvGNUTransService::makeNewXMLTranscoder
(
const XMLCh* const encodingName
, XMLTransService::Codes& resValue
, const unsigned int blockSize
)
{
resValue = XMLTransService::UnsupportedEncoding;
IconvGNUTranscoder *newTranscoder = NULL;
char *encLocal = XMLString::transcode(encodingName);
iconv_t cd_from, cd_to;
{
ICONV_LOCK;
cd_from = iconv_open (fUnicodeCP, encLocal);
if (cd_from == (iconv_t)-1) {
resValue = XMLTransService::SupportFilesNotFound;
if (encLocal)
delete [] encLocal;
return NULL;
}
cd_to = iconv_open (encLocal, fUnicodeCP);
if (cd_to == (iconv_t)-1) {
resValue = XMLTransService::SupportFilesNotFound;
iconv_close (cd_from);
if (encLocal)
delete [] encLocal;
return NULL;
}
newTranscoder = new IconvGNUTranscoder (encodingName,
blockSize,
cd_from, cd_to,
uChSize(), UBO());
}
if (newTranscoder)
resValue = XMLTransService::Ok;
if (encLocal)
delete [] encLocal;
return newTranscoder;
}
void IconvGNUTransService::upperCase(XMLCh* const toUpperCase) const
{
XMLCh* outPtr = toUpperCase;
while (*outPtr)
{
*outPtr = toUpper(*outPtr);
outPtr++;
}
}
void IconvGNUTransService::lowerCase(XMLCh* const toLowerCase) const
{
XMLCh* outPtr = toLowerCase;
while (*outPtr)
{
*outPtr = toLower(*outPtr);
outPtr++;
}
}
// ---------------------------------------------------------------------------
// IconvGNULCPTranscoder: The virtual transcoder API
// ---------------------------------------------------------------------------
unsigned int
IconvGNULCPTranscoder::calcRequiredSize (const char* const srcText)
{
if (!srcText)
return 0;
size_t len, srcLen;
len = srcLen = strlen(srcText);
if (len == 0)
return 0;
char tmpWideArr[gTempBuffArraySize];
size_t totalLen = 0;
for (;;) {
char *pTmpArr = tmpWideArr;
const char *ptr = srcText + srcLen - len;
size_t rc = iconvFrom(ptr, &len, &pTmpArr, gTempBuffArraySize);
if (rc == (size_t) -1 && errno != E2BIG) {
ThrowXML(TranscodingException, XMLExcepts::Trans_BadSrcSeq);
/* return 0; */
}
rc = pTmpArr - (char *) tmpWideArr;
totalLen += rc;
if (rc == 0 || len == 0)
break;
}
return totalLen / uChSize();
}
unsigned int
IconvGNULCPTranscoder::calcRequiredSize(const XMLCh* const srcText)
{
if (!srcText)
return 0;
unsigned int wLent = getWideCharLength(srcText);
if (wLent == 0)
return 0;
char tmpWBuff[gTempBuffArraySize];
char *wBuf = 0;
char *wBufPtr = 0;
size_t len = wLent * uChSize();
if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
if (len > gTempBuffArraySize) {
wBufPtr = new char[len];
if (wBufPtr == NULL)
return 0;
wBuf = wBufPtr;
} else
wBuf = tmpWBuff;
xmlToMbs (srcText, wLent, wBuf, wLent);
} else
wBuf = (char *) srcText;
char tmpBuff[gTempBuffArraySize];
size_t totalLen = 0;
char *srcEnd = wBuf + wLent * uChSize();
for (;;) {
char *pTmpArr = tmpBuff;
const char *ptr = srcEnd - len;
size_t rc = iconvTo(ptr, &len, &pTmpArr, gTempBuffArraySize);
if (rc == (size_t) -1 && errno != E2BIG) {
if (wBufPtr)
delete [] wBufPtr;
ThrowXML(TranscodingException, XMLExcepts::Trans_BadSrcSeq);
/* return 0; */
}
rc = pTmpArr - tmpBuff;
totalLen += rc;
if (rc == 0 || len == 0)
break;
}
if (wBufPtr)
delete [] wBufPtr;
return totalLen;
}
char* IconvGNULCPTranscoder::transcode(const XMLCh* const toTranscode)
{
if (!toTranscode)
return 0;
char* retVal = 0;
if (*toTranscode) {
unsigned int wLent = getWideCharLength(toTranscode);
// Calc needed size.
const size_t neededLen = calcRequiredSize (toTranscode);
if (neededLen == 0)
return 0;
// allocate output buffer
retVal = new char[neededLen + 1];
if (retVal == NULL)
return 0;
// prepare the original
char tmpWBuff[gTempBuffArraySize];
char *wideCharBuf = 0;
char *wBufPtr = 0;
size_t len = wLent * uChSize();
if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
if (len > gTempBuffArraySize) {
wBufPtr = new char[len];
if (wBufPtr == NULL)
return 0;
wideCharBuf = wBufPtr;
} else
wideCharBuf = tmpWBuff;
xmlToMbs (toTranscode, wLent, wideCharBuf, wLent);
} else
wideCharBuf = (char *) toTranscode;
// perform conversion
wLent *= uChSize();
char *ptr = retVal;
size_t rc = iconvTo(wideCharBuf, &wLent, &ptr, neededLen);
if (rc == (size_t)-1) {
if (wBufPtr)
delete [] wBufPtr;
return 0;
}
if (wBufPtr)
delete [] wBufPtr;
retVal[neededLen] = 0;
} else {
retVal = new char[1];
if (retVal == NULL)
return 0;
retVal[0] = 0;
}
return retVal;
}
bool IconvGNULCPTranscoder::transcode( const XMLCh* const toTranscode
, char* const toFill
, const unsigned int maxBytes)
{
// Watch for a couple of pyscho corner cases
if (!toTranscode || !maxBytes) {
toFill[0] = 0;
return true;
}
if (!*toTranscode) {
toFill[0] = 0;
return true;
}
unsigned int wLent = getWideCharLength(toTranscode);
if (wLent > maxBytes)
wLent = maxBytes;
// Fill the "unicode" string
char tmpWBuff[gTempBuffArraySize];
char *wideCharBuf = 0;
char *wBufPtr = 0;
size_t len = wLent * uChSize();
if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
if (len > gTempBuffArraySize) {
wBufPtr = new char[len];
if (wBufPtr == NULL)
return 0;
wideCharBuf = wBufPtr;
} else
wideCharBuf = tmpWBuff;
xmlToMbs (toTranscode, wLent, wideCharBuf, wLent);
} else
wideCharBuf = (char *) toTranscode;
// Ok, go ahead and try the transcoding. If it fails, then ...
char *ptr = toFill;
size_t rc = iconvTo(wideCharBuf, &len, &ptr, maxBytes);
if (rc == (size_t)-1) {
if (wBufPtr)
delete [] wBufPtr;
return false;
}
if (wBufPtr)
delete [] wBufPtr;
// Cap it off just in case
toFill[wLent] = 0;
return true;
}
XMLCh* IconvGNULCPTranscoder::transcode(const char* const toTranscode)
{
if (!toTranscode)
return 0;
XMLCh* retVal = 0;
if (*toTranscode) {
const unsigned int wLent = calcRequiredSize(toTranscode);
if (wLent == 0) {
retVal = new XMLCh[1];
retVal[0] = 0;
return retVal;
}
char tmpWBuff[gTempBuffArraySize];
char *wideCharBuf = 0;
char *wBufPtr = 0;
size_t len = wLent * uChSize();
retVal = new XMLCh[wLent + 1];
if (retVal == NULL)
return NULL;
if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
if (len > gTempBuffArraySize) {
wBufPtr = new char[len];
if (wBufPtr == NULL)
return 0;
wideCharBuf = wBufPtr;
} else
wideCharBuf = tmpWBuff;
} else
wideCharBuf = (char *) retVal;
size_t flen = strlen(toTranscode);
char *ptr = wideCharBuf;
size_t rc = iconvFrom(toTranscode, &flen, &ptr, len);
if (rc == (size_t) -1) {
if (wBufPtr)
delete [] wBufPtr;
return NULL;
}
if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER)
mbsToXML (wideCharBuf, wLent, retVal, wLent);
if (wBufPtr)
delete [] wBufPtr;
retVal[wLent] = 0x00;
}
else {
retVal = new XMLCh[1];
if (retVal == NULL )
return 0;
retVal[0] = 0;
}
return retVal;
}
bool IconvGNULCPTranscoder::transcode(const char* const toTranscode
, XMLCh* const toFill
, const unsigned int maxChars)
{
// Check for a couple of psycho corner cases
if (!toTranscode || !maxChars)
{
toFill[0] = 0;
return true;
}
if (!*toTranscode)
{
toFill[0] = 0;
return true;
}
size_t wLent = calcRequiredSize(toTranscode);
if (wLent > maxChars)
wLent = maxChars;
char tmpWBuff[gTempBuffArraySize];
char *wideCharBuf = 0;
char *wBufPtr = 0;
size_t len = wLent * uChSize();
if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
if (len > gTempBuffArraySize) {
wBufPtr = new char[len];
if (wBufPtr == NULL)
return 0;
wideCharBuf = wBufPtr;
} else
wideCharBuf = tmpWBuff;
} else
wideCharBuf = (char *) toFill;
size_t flen = strlen(toTranscode); // wLent;
char *ptr = wideCharBuf;
size_t rc = iconvFrom(toTranscode, &flen, &ptr, len);
if (rc == (size_t)-1) {
if (wBufPtr)
delete [] wBufPtr;
return false;
}
if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER)
mbsToXML (wideCharBuf, wLent, toFill, wLent);
if (wBufPtr)
delete [] wBufPtr;
toFill[wLent] = 0x00;
return true;
}
// ---------------------------------------------------------------------------
// IconvGNULCPTranscoder: Constructors and Destructor
// ---------------------------------------------------------------------------
IconvGNULCPTranscoder::IconvGNULCPTranscoder (iconv_t cd_from,
iconv_t cd_to,
size_t uchsize,
unsigned int ubo)
: IconvGNUWrapper (cd_from, cd_to, uchsize, ubo)
{
}
IconvGNULCPTranscoder::~IconvGNULCPTranscoder()
{
}
// ---------------------------------------------------------------------------
// IconvGNUTranscoder: Constructors and Destructor
// ---------------------------------------------------------------------------
IconvGNUTranscoder::IconvGNUTranscoder (const XMLCh* const encodingName
, const unsigned int blockSize
, iconv_t cd_from
, iconv_t cd_to
, size_t uchsize
, unsigned int ubo
)
: XMLTranscoder(encodingName, blockSize)
, IconvGNUWrapper (cd_from, cd_to, uchsize, ubo)
{
}
IconvGNUTranscoder::~IconvGNUTranscoder()
{
ICONV_LOCK;
if (cdTo() != (iconv_t)-1) {
iconv_close (cdTo());
setCDTo ((iconv_t)-1);
}
if (cdFrom() != (iconv_t)-1) {
iconv_close (cdFrom());
setCDFrom ((iconv_t)-1);
}
}
// ---------------------------------------------------------------------------
// IconvGNUTranscoder: Implementation of the virtual transcoder API
// ---------------------------------------------------------------------------
unsigned int IconvGNUTranscoder::transcodeFrom
(
const XMLByte* const srcData
, const unsigned int srcCount
, XMLCh* const toFill
, const unsigned int maxChars
, unsigned int& bytesEaten
, unsigned char* const charSizes )
{
// Transcode TO XMLCh
const char* startSrc = (const char*) srcData;
const char* endSrc = (const char*) srcData + srcCount;
char tmpWBuff[gTempBuffArraySize];
char *startTarget = 0;
char *wBufPtr = 0;
size_t len = maxChars * uChSize();
if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
if (len > gTempBuffArraySize) {
wBufPtr = new char[len];
if (wBufPtr == NULL)
return 0;
startTarget = wBufPtr;
} else
startTarget = tmpWBuff;
} else
startTarget = (char *) toFill;
// Do character-by-character transcoding
char *orgTarget = startTarget;
size_t srcLen = srcCount;
size_t prevSrcLen = srcLen;
unsigned int toReturn = 0;
bytesEaten = 0;
for (size_t cnt = 0; cnt < maxChars && srcLen; cnt++) {
size_t rc = iconvFrom(startSrc, &srcLen, &orgTarget, uChSize());
if (rc == (size_t)-1) {
if (errno != E2BIG || prevSrcLen == srcLen) {
if (wBufPtr)
delete [] wBufPtr;
ThrowXML(TranscodingException, XMLExcepts::Trans_BadSrcSeq);
}
}
charSizes[cnt] = prevSrcLen - srcLen;
prevSrcLen = srcLen;
bytesEaten += charSizes[cnt];
startSrc = endSrc - srcLen;
toReturn++;
}
if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER)
mbsToXML (startTarget, toReturn, toFill, toReturn);
if (wBufPtr)
delete [] wBufPtr;
return toReturn;
}
unsigned int IconvGNUTranscoder::transcodeTo
(
const XMLCh* const srcData
, const unsigned int srcCount
, XMLByte* const toFill
, const unsigned int maxBytes
, unsigned int& charsEaten
, const UnRepOpts options )
{
// Transcode FROM XMLCh
char tmpWBuff[gTempBuffArraySize];
char *startSrc = tmpWBuff;
char *wBufPtr = 0;
size_t len = srcCount * uChSize();
if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
if (len > gTempBuffArraySize) {
wBufPtr = new char[len];
if (wBufPtr == NULL)
return 0;
startSrc = wBufPtr;
} else
startSrc = tmpWBuff;
xmlToMbs (srcData, srcCount, startSrc, srcCount);
} else
startSrc = (char *) srcData;
char* startTarget = (char *) toFill;
size_t srcLen = len;
size_t rc = iconvTo (startSrc, &srcLen, &startTarget, maxBytes);
if (rc == (size_t)-1 && errno != E2BIG) {
if (wBufPtr)
delete [] wBufPtr;
ThrowXML(TranscodingException, XMLExcepts::Trans_BadSrcSeq);
}
charsEaten = srcCount - srcLen / uChSize();
if (wBufPtr)
delete [] wBufPtr;
return startTarget - (char *)toFill;
}
bool IconvGNUTranscoder::canTranscodeTo
(
const unsigned int toCheck
) const
{
//
// If the passed value is really a surrogate embedded together, then
// we need to break it out into its two chars. Else just one.
//
char srcBuf[2 * uChSize()];
unsigned int srcCount = 1;
if (toCheck & 0xFFFF0000) {
XMLCh ch1 = (toCheck >> 10) + 0xD800;
XMLCh ch2 = toCheck & 0x3FF + 0xDC00;
xmlToMbs(&ch1, 1, srcBuf, 1);
xmlToMbs(&ch2, 1, srcBuf + uChSize(), 1);
srcCount++;
} else
xmlToMbs((const XMLCh*) &toCheck, 1, srcBuf, 1);
size_t len = srcCount * uChSize();
char tmpBuf[64];
char* pTmpBuf = tmpBuf;
size_t rc = iconvTo( srcBuf, &len, &pTmpBuf, 64);
return (rc != (size_t)-1) && (len == 0);
}
1.1
xml-xerces/c/src/xercesc/util/Transcoders/IconvGNU/IconvGNUTransService.hpp
Index: IconvGNUTransService.hpp
===================================================================
/*
* The Apache Software License, Version 1.1
*
* Copyright (c) 2002 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Xerces" and "Apache Software Foundation" must
* not be used to endorse or promote products derived from this
* software without prior written permission. For written
* permission, please contact apache\@apache.org.
*
* 5. Products derived from this software may not be called "Apache",
* nor may "Apache" appear in their name, without prior written
* permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation, and was
* originally based on software copyright (c) 2001, International
* Business Machines, Inc., http://www.ibm.com . For more information
* on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*/
/*
* $Log: IconvGNUTransService.hpp,v $
* Revision 1.1 2002/08/19 19:38:18 tng
* [Bug 11771] Linux specific IconvGNU transcoder. Patch from Vasily Tchekalkin.
*
*/
#ifndef ICONVGNUTRANSSERVICE_HPP
#define ICONVGNUTRANSSERVICE_HPP
#include <xercesc/util/TransService.hpp>
#include <iconv.h>
// ---------------------------------------------------------------------------
// Libiconv wrapper (low-level conversion utilities collection)
// ---------------------------------------------------------------------------
class XMLUTIL_EXPORT IconvGNUWrapper
{
public:
// -----------------------------------------------------------------------
// Constructors and Destructor
// -----------------------------------------------------------------------
IconvGNUWrapper
(
iconv_t cd_from,
iconv_t cd_to,
size_t uchsize,
unsigned int ubo
);
virtual ~IconvGNUWrapper();
// Convert "native unicode" character into XMLCh
void mbcToXMLCh (const char *mbc, XMLCh *toRet) const;
// Convert XMLCh into "native unicode" character
void xmlChToMbc (XMLCh xch, char *mbc) const;
// Return uppercase equivalent for XMLCh
XMLCh toUpper (const XMLCh ch) const;
// Return uppercase equivalent for XMLCh
XMLCh toLower (const XMLCh ch) const;
// Check if passed characters belongs to the :space: class
virtual bool isSpace(const XMLCh toCheck) const;
// Fill array of XMLCh characters with data, supplyed in the array
// of "native unicode" characters.
XMLCh* mbsToXML (
const char* mbs_str,
size_t mbs_cnt,
XMLCh* xml_str,
size_t xml_cnt
) const;
// Fill array of "native unicode" characters with data, supplyed
// in the array of XMLCh characters.
char* xmlToMbs
(
const XMLCh* xml_str,
size_t xml_cnt,
char* mbs_str,
size_t mbs_cnt
) const;
// Wrapper aroung the iconv() for transcoding from the local charset
size_t iconvFrom
(
const char *fromPtr,
size_t *fromLen,
char **toPtr,
size_t toLen
) const;
// Wrapper aroung the iconv() for transcoding to the local charset
size_t iconvTo
(
const char *fromPtr,
size_t *fromLen,
char **toPtr,
size_t toLen
) const;
// Private data accessors
inline iconv_t cdTo () const { return fCDTo; }
inline iconv_t cdFrom () const { return fCDFrom; }
inline size_t uChSize () const { return fUChSize; }
inline unsigned int UBO () const { return fUBO; }
protected:
// Hiden defaull constructor
IconvGNUWrapper();
// Private data accessors
inline void setCDTo (iconv_t cd) { fCDTo = cd; }
inline void setCDFrom (iconv_t cd) { fCDFrom = cd; }
inline void setUChSize (size_t sz) { fUChSize = sz; }
inline void setUBO (unsigned int u) { fUBO = u; }
private:
// -----------------------------------------------------------------------
// Unimplemented constructors and operators
// -----------------------------------------------------------------------
IconvGNUWrapper(const IconvGNUWrapper&);
void operator=(const IconvGNUWrapper&);
// -----------------------------------------------------------------------
// Private data members
//
// fCDTo
// Characterset conversion descriptor TO the local-host encoding
// fCDFrom
// Characterset conversion descriptor FROM the local-host encoding
// fUChSize
// Sizeof the "native unicode" character in bytes
// fUBO
// "Native unicode" characters byte order
// -----------------------------------------------------------------------
size_t fUChSize;
unsigned int fUBO;
iconv_t fCDTo;
iconv_t fCDFrom;
};
// ---------------------------------------------------------------------------
// FreeBSD-specific Transcoding Service implementation
// ---------------------------------------------------------------------------
class XMLUTIL_EXPORT IconvGNUTransService : public XMLTransService, IconvGNUWrapper
{
public :
// -----------------------------------------------------------------------
// Constructors and Destructor
// -----------------------------------------------------------------------
IconvGNUTransService();
~IconvGNUTransService();
// -----------------------------------------------------------------------
// Implementation of the virtual transcoding service API
// -----------------------------------------------------------------------
virtual int compareIString
(
const XMLCh* const comp1
, const XMLCh* const comp2
);
virtual int compareNIString
(
const XMLCh* const comp1
, const XMLCh* const comp2
, const unsigned int maxChars
);
virtual const XMLCh* getId() const;
virtual bool isSpace(const XMLCh toCheck) const;
virtual XMLLCPTranscoder* makeNewLCPTranscoder();
virtual bool supportsSrcOfs() const;
virtual void upperCase(XMLCh* const toUpperCase) const;
virtual void lowerCase(XMLCh* const toUpperCase) const;
protected :
// -----------------------------------------------------------------------
// Protected virtual methods
// -----------------------------------------------------------------------
virtual XMLTranscoder* makeNewXMLTranscoder
(
const XMLCh* const encodingName
, XMLTransService::Codes& resValue
, const unsigned int blockSize
);
private :
// -----------------------------------------------------------------------
// Unimplemented constructors and operators
// -----------------------------------------------------------------------
IconvGNUTransService(const IconvGNUTransService&);
void operator=(const IconvGNUTransService&);
// -----------------------------------------------------------------------
// Private data members
//
// fUnicodeCP
// Unicode encoding schema name
// -----------------------------------------------------------------------
const char* fUnicodeCP;
};
//----------------------------------------------------------------------------
// Implementation of the transcoders for arbitrary input characterset is
// supported ONLY through libiconv interface
//----------------------------------------------------------------------------
class XMLUTIL_EXPORT IconvGNUTranscoder : public XMLTranscoder, IconvGNUWrapper
{
public :
// -----------------------------------------------------------------------
// Constructors and Destructor
// -----------------------------------------------------------------------
IconvGNUTranscoder(const XMLCh* const encodingName
, const unsigned int blockSize
, iconv_t cd_from
, iconv_t cd_to
, size_t uchsize
, unsigned int ubo
);
~IconvGNUTranscoder();
// -----------------------------------------------------------------------
// Implementation of the virtual transcoder interface
// -----------------------------------------------------------------------
virtual unsigned int transcodeFrom
(
const XMLByte* const srcData
, const unsigned int srcCount
, XMLCh* const toFill
, const unsigned int maxChars
, unsigned int& bytesEaten
, unsigned char* const charSizes
);
virtual unsigned int transcodeTo
(
const XMLCh* const srcData
, const unsigned int srcCount
, XMLByte* const toFill
, const unsigned int maxBytes
, unsigned int& charsEaten
, const UnRepOpts options
);
virtual bool canTranscodeTo
(
const unsigned int toCheck
) const;
private :
// -----------------------------------------------------------------------
// Unimplemented constructors and operators
// -----------------------------------------------------------------------
IconvGNUTranscoder();
IconvGNUTranscoder(const IconvGNUTranscoder&);
void operator=(const IconvGNUTranscoder&);
};
// ---------------------------------------------------------------------------
// GNU-specific XMLCh <-> local (host) characterset transcoder
// ---------------------------------------------------------------------------
class XMLUTIL_EXPORT IconvGNULCPTranscoder : public XMLLCPTranscoder, IconvGNUWrapper
{
public :
// -----------------------------------------------------------------------
// Constructors and Destructor
// -----------------------------------------------------------------------
IconvGNULCPTranscoder
(
iconv_t from,
iconv_t to,
size_t uchsize,
unsigned int ubo
);
protected:
IconvGNULCPTranscoder(); // Unimplemented
public:
~IconvGNULCPTranscoder();
// -----------------------------------------------------------------------
// Implementation of the virtual transcoder interface
// -----------------------------------------------------------------------
virtual unsigned int calcRequiredSize(const char* const srcText);
virtual unsigned int calcRequiredSize(const XMLCh* const srcText);
virtual char* transcode(const XMLCh* const toTranscode);
virtual bool transcode
(
const XMLCh* const toTranscode
, char* const toFill
, const unsigned int maxBytes
);
virtual XMLCh* transcode(const char* const toTranscode);
virtual bool transcode
(
const char* const toTranscode
, XMLCh* const toFill
, const unsigned int maxChars
);
private :
// -----------------------------------------------------------------------
// Unimplemented constructors and operators
// -----------------------------------------------------------------------
IconvGNULCPTranscoder(const IconvGNULCPTranscoder&);
void operator=(const IconvGNULCPTranscoder&);
};
#endif /* ICONVGNUTRANSSERVICE */
1.1 xml-xerces/c/src/xercesc/util/Transcoders/IconvGNU/Makefile.in
Index: Makefile.in
===================================================================
#
# The Apache Software License, Version 1.1
#
# Copyright (c) 2002 The Apache Software Foundation. All rights
# reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# 1. Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
#
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
#
# 3. The end-user documentation included with the redistribution,
# if any, must include the following acknowledgment:
# "This product includes software developed by the
# Apache Software Foundation (http://www.apache.org/)."
# Alternately, this acknowledgment may appear in the software itself,
# if and wherever such third-party acknowledgments normally appear.
#
# 4. The names "Xerces" and "Apache Software Foundation" must
# not be used to endorse or promote products derived from this
# software without prior written permission. For written
# permission, please contact apache\@apache.org.
#
# 5. Products derived from this software may not be called "Apache",
# nor may "Apache" appear in their name, without prior written
# permission of the Apache Software Foundation.
#
# THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
# WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
# ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
# OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
# SUCH DAMAGE.
# ====================================================================
#
# This software consists of voluntary contributions made by many
# individuals on behalf of the Apache Software Foundation, and was
# originally based on software copyright (c) 2001, International
# Business Machines, Inc., http://www.ibm.com . For more information
# on the Apache Software Foundation, please see
# <http://www.apache.org/>.
#
#
# $Log: Makefile.in,v $
# Revision 1.1 2002/08/19 19:38:18 tng
# [Bug 11771] Linux specific IconvGNU transcoder. Patch from Vasily Tchekalkin.
#
# Revision 1.2 2002/07/26 16:49:29 tng
# [Bug 2681] Can't build with gcc/g++ not named 'gcc'/'g++'. Patch from Jonathan
Lennox.
#
# Revision 1.1.1.1 2002/02/01 22:22:36 peiyongz
# sane_include
#
# Revision 1.1 2001/12/03 14:45:11 tng
# FreeBSD native transcoder (IconvFBSD) added by Max Gotlib.
#
#
PLATFORM = @platform@
CC = @cc@
CXX = @cxx@
GCC = @GCC@
GXX = @GXX@
CXXFLAGS = @cxxflags@
CFLAGS = @cflags@
PREFIX = @prefix@
PREFIX_INCLUDE = @prefix_include@
LDFLAGS = @ldflags@
LIBS = @libs@
OSVER = @osver@
USELIBWWW = @uselibwww@
MESSAGELOADER = @messageloader@
TRANSCODER = @transcoder@
THREADS = @threads@
MODULE = util
SUBMODULE = Transcoders/IconvGNU
include ../../../Makefile.incl
CPP_PUBHEADERS = IconvGNUTransService.hpp
CPP_OBJECTS = IconvGNUTransService.$(TO)
include ../../Makefile.util.submodule
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
