tng 2002/12/31 10:42:54
Modified: c/src/xercesc/util/Transcoders/IconvGNU
IconvGNUTransService.cpp
Log:
[Bug 15608] IconvLCPTranscoder::transcode() is wrong at wcstombs() usage.
Revision Changes Path
1.4 +533 -530
xml-xerces/c/src/xercesc/util/Transcoders/IconvGNU/IconvGNUTransService.cpp
Index: IconvGNUTransService.cpp
===================================================================
RCS file:
/home/cvs/xml-xerces/c/src/xercesc/util/Transcoders/IconvGNU/IconvGNUTransService.cpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -r1.3 -r1.4
--- IconvGNUTransService.cpp 4 Nov 2002 15:14:34 -0000 1.3
+++ IconvGNUTransService.cpp 31 Dec 2002 18:42:54 -0000 1.4
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.4 2002/12/31 18:42:54 tng
+ * [Bug 15608] IconvLCPTranscoder::transcode() is wrong at wcstombs() usage.
+ *
* Revision 1.3 2002/11/04 15:14:34 tng
* C++ Namespace Support.
*
@@ -83,15 +86,15 @@
// 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
+ 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 }
+static const IconvGNUEncoding gIconvGNUEncodings[] = {
+ { "UCS-2LE", 2, LITTLE_ENDIAN },
+ { "ucs-2-internal", 2, LITTLE_ENDIAN },
+ { NULL, 0, 0 }
};
//--------------------------------------------------
@@ -100,59 +103,59 @@
// 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))
+# 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))
+# 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>
@@ -172,8 +175,8 @@
// ---------------------------------------------------------------------------
// Local, const data
// ---------------------------------------------------------------------------
-static const unsigned int gTempBuffArraySize = 4096;
-static const XMLCh gMyServiceId[] =
+static const unsigned int gTempBuffArraySize = 4096;
+static const XMLCh gMyServiceId[] =
{
chLatin_I, chLatin_C, chLatin_o, chLatin_n, chLatin_v, chNull
};
@@ -199,8 +202,8 @@
#include <xercesc/util/Mutexes.hpp>
// Iconv() access syncronization point
-static XMLMutex *gIconvMutex = NULL;
-# define ICONV_LOCK XMLMutexLock lockConverter(gIconvMutex);
+static XMLMutex *gIconvMutex = NULL;
+# define ICONV_LOCK XMLMutexLock lockConverter(gIconvMutex);
#else /* APP_NO_THREADS */
@@ -219,15 +222,15 @@
{
}
-IconvGNUWrapper::IconvGNUWrapper ( iconv_t cd_from,
- iconv_t cd_to,
- size_t uchsize,
- unsigned int ubo )
+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);
+ XMLPlatformUtils::panic (XMLPlatformUtils::Panic_NoTransService);
}
}
@@ -236,66 +239,66 @@
}
// Convert "native unicode" character into XMLCh
-void IconvGNUWrapper::mbcToXMLCh (const char *mbc, XMLCh *toRet) const
+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 );
- }
+ 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 );
- }
+ if (fUChSize == 2) {
+ IWC162XMLCh( mbc, toRet );
+ } else {
+ IWC322XMLCh( mbc, toRet );
+ }
}
}
// Convert XMLCh into "native unicode" character
-void IconvGNUWrapper::xmlChToMbc (XMLCh xch, char *mbc) const
+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 );
- }
+ 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 );
- }
+ if (fUChSize == 2) {
+ IXMLCh2WC16( &xch, mbc );
+ } else {
+ IXMLCh2WC32( &xch, mbc );
+ }
}
}
// Return uppercase equivalent for XMLCh
-XMLCh IconvGNUWrapper::toUpper (const XMLCh ch) const
+XMLCh IconvGNUWrapper::toUpper (const XMLCh ch) const
{
if (ch <= 0x7F)
- return toupper(ch);
+ return toupper(ch);
- char wcbuf[fUChSize * 2];
+ char wcbuf[fUChSize * 2];
xmlChToMbc (ch, wcbuf);
- char tmpArr[4];
- char* ptr = wcbuf;
- size_t len = fUChSize;
- char *pTmpArr = tmpArr;
- size_t bLen = 2;
+ 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;
+ &pTmpArr, &bLen) == (size_t) -1)
+ return 0;
tmpArr[1] = toupper (*((unsigned char *)tmpArr));
*tmpArr = tmpArr[1];
len = 1;
@@ -303,31 +306,31 @@
bLen = fUChSize;
ptr = tmpArr;
if (::iconv (fCDFrom, &ptr, &len,
- &pTmpArr, &bLen) == (size_t) -1)
- return 0;
+ &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
+XMLCh IconvGNUWrapper::toLower (const XMLCh ch) const
{
if (ch <= 0x7F)
- return tolower(ch);
+ return tolower(ch);
- char wcbuf[fUChSize * 2];
+ char wcbuf[fUChSize * 2];
xmlChToMbc (ch, wcbuf);
- char tmpArr[4];
- char* ptr = wcbuf;
- size_t len = fUChSize;
- char *pTmpArr = tmpArr;
- size_t bLen = 2;
+ 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;
+ &pTmpArr, &bLen) == (size_t) -1)
+ return 0;
tmpArr[1] = tolower (*((unsigned char*)tmpArr));
*tmpArr = tmpArr[1];
len = 1;
@@ -335,131 +338,131 @@
bLen = fUChSize;
ptr = tmpArr;
if (::iconv (fCDFrom, &ptr, &len,
- &pTmpArr, &bLen) == (size_t) -1)
- return 0;
+ &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
+bool IconvGNUWrapper::isSpace(const XMLCh toCheck) const
{
if (toCheck <= 0x7F)
- return isspace(toCheck);
+ return isspace(toCheck);
- char wcbuf[fUChSize * 2];
- char tmpArr[4];
+ char wcbuf[fUChSize * 2];
+ char tmpArr[4];
xmlChToMbc (toCheck, wcbuf);
- char* ptr = wcbuf;
- size_t len = fUChSize;
- char *pTmpArr = tmpArr;
- size_t bLen = 2;
+ 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;
+ 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
+XMLCh* IconvGNUWrapper::mbsToXML
(
- const char* mbs_str
- , size_t mbs_cnt
- , XMLCh* xml_str
- , size_t xml_cnt
+ 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;
+ 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 );
- }
+ 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 );
- }
+ 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
+char* IconvGNUWrapper::xmlToMbs
(
- const XMLCh* xml_str
- , size_t xml_cnt
- , char* mbs_str
- , size_t mbs_cnt
+ 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;
+ 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 );
- }
+ 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 );
- }
+ 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
+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
+size_t IconvGNUWrapper::iconvTo ( const char *fromPtr,
+ size_t *fromLen,
+ char **toPtr,
+ size_t toLen ) const
{
ICONV_LOCK;
char ** tmpPtr = (char**)&fromPtr;
@@ -477,111 +480,111 @@
#if !defined(APP_NO_THREADS)
// Create global lock object
if (gIconvMutex == NULL) {
- gIconvMutex = new XMLMutex;
- if (gIconvMutex == NULL)
- XMLPlatformUtils::panic (XMLPlatformUtils::Panic_NoTransService);
+ 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, "");
+ char* fLocalCP = setlocale (LC_CTYPE, "");
if (fLocalCP == NULL)
- fLocalCP = "iso-8859-1"; // fallback locale
+ fLocalCP = "iso-8859-1"; // fallback locale
else {
- char *ptr = strchr (fLocalCP, '.');
- if (ptr == NULL)
- fLocalCP = "iso-8859-1"; // fallback locale
- else
- fLocalCP = ptr + 1;
+ 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;
+ 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 (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;
- }
+ // 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);
+ XMLPlatformUtils::panic (XMLPlatformUtils::Panic_NoTransService);
}
IconvGNUTransService::~IconvGNUTransService()
{
if (cdTo() != (iconv_t) -1) {
- iconv_close (cdTo());
- setCDTo ((iconv_t)-1);
+ iconv_close (cdTo());
+ setCDTo ((iconv_t)-1);
}
if (cdFrom() != (iconv_t) -1) {
- iconv_close (cdFrom());
- setCDFrom ((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)
+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);
+ XMLCh c1 = toUpper(*cptr1);
+ XMLCh c2 = toUpper(*cptr2);
while ( (*cptr1 != 0) && (*cptr2 != 0) ) {
if (c1 != c2)
break;
- c1 = toUpper(*(++cptr1));
- c2 = toUpper(*(++cptr2));
+ 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)
+int IconvGNUTransService::compareNIString(const XMLCh* const comp1
+ , const XMLCh* const comp2
+ , const unsigned int maxChars)
{
unsigned int n = 0;
const XMLCh* cptr1 = comp1;
@@ -589,10 +592,10 @@
while (true && maxChars)
{
- XMLCh c1 = toUpper(*cptr1);
- XMLCh c2 = toUpper(*cptr2);
+ XMLCh c1 = toUpper(*cptr1);
+ XMLCh c2 = toUpper(*cptr2);
- if (c1 != c2)
+ if (c1 != c2)
return (int) (c1 - c2);
// If either ended, then both ended, so equal
@@ -642,43 +645,43 @@
XMLTranscoder*
IconvGNUTransService::makeNewXMLTranscoder
(
- const XMLCh* const encodingName
- , XMLTransService::Codes& resValue
- , const unsigned int blockSize
+ const XMLCh* const encodingName
+ , XMLTransService::Codes& resValue
+ , const unsigned int blockSize
)
{
resValue = XMLTransService::UnsupportedEncoding;
- IconvGNUTranscoder *newTranscoder = NULL;
+ IconvGNUTranscoder *newTranscoder = NULL;
- char *encLocal = XMLString::transcode(encodingName);
- iconv_t cd_from, cd_to;
+ 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());
+ 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;
+ resValue = XMLTransService::Ok;
if (encLocal)
- delete [] encLocal;
+ delete [] encLocal;
return newTranscoder;
}
@@ -687,7 +690,7 @@
XMLCh* outPtr = toUpperCase;
while (*outPtr)
{
- *outPtr = toUpper(*outPtr);
+ *outPtr = toUpper(*outPtr);
outPtr++;
}
}
@@ -697,7 +700,7 @@
XMLCh* outPtr = toLowerCase;
while (*outPtr)
{
- *outPtr = toLower(*outPtr);
+ *outPtr = toLower(*outPtr);
outPtr++;
}
}
@@ -716,21 +719,21 @@
if (len == 0)
return 0;
- char tmpWideArr[gTempBuffArraySize];
- size_t totalLen = 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;
+ 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();
}
@@ -745,43 +748,43 @@
if (wLent == 0)
return 0;
- char tmpWBuff[gTempBuffArraySize];
- char *wBuf = 0;
- char *wBufPtr = 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);
+ 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;
+ wBuf = (char *) srcText;
- char tmpBuff[gTempBuffArraySize];
- size_t totalLen = 0;
- char *srcEnd = wBuf + wLent * uChSize();
+ 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;
+ 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;
+ delete [] wBufPtr;
return totalLen;
}
@@ -796,57 +799,57 @@
unsigned int wLent = getWideCharLength(toTranscode);
// Calc needed size.
- const size_t neededLen = calcRequiredSize (toTranscode);
+ const size_t neededLen = calcRequiredSize (toTranscode);
if (neededLen == 0)
return 0;
- // allocate output buffer
+ // allocate output buffer
retVal = new char[neededLen + 1];
- if (retVal == NULL)
+ 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, (size_t *) &wLent, &ptr, neededLen);
+ if (rc == (size_t)-1) {
+ if (wBufPtr)
+ delete [] wBufPtr;
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, (size_t *) &wLent, &ptr, neededLen);
- if (rc == (size_t)-1) {
- if (wBufPtr)
- delete [] wBufPtr;
- return 0;
- }
- if (wBufPtr)
- delete [] wBufPtr;
+ }
+ if (wBufPtr)
+ delete [] wBufPtr;
retVal[neededLen] = 0;
} else {
retVal = new char[1];
- if (retVal == NULL)
- return 0;
+ if (retVal == NULL)
+ return 0;
retVal[0] = 0;
}
return retVal;
}
-bool IconvGNULCPTranscoder::transcode( const XMLCh* const toTranscode
- , char* const toFill
- , const unsigned int maxBytes)
+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) {
@@ -863,36 +866,36 @@
wLent = maxBytes;
// Fill the "unicode" string
- char tmpWBuff[gTempBuffArraySize];
- char *wideCharBuf = 0;
- char *wBufPtr = 0;
+ 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);
+ 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;
+ 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);
+ 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;
+ return false;
}
if (wBufPtr)
- delete [] wBufPtr;
+ delete [] wBufPtr;
// Cap it off just in case
- toFill[wLent] = 0;
+ toFill[rc] = 0;
return true;
}
@@ -912,52 +915,52 @@
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;
+ 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;
+ if (retVal == NULL )
+ return 0;
retVal[0] = 0;
}
return retVal;
}
-bool IconvGNULCPTranscoder::transcode(const char* const toTranscode
- , XMLCh* const toFill
- , const unsigned int maxChars)
+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)
@@ -976,35 +979,35 @@
if (wLent > maxChars)
wLent = maxChars;
- char tmpWBuff[gTempBuffArraySize];
- char *wideCharBuf = 0;
- char *wBufPtr = 0;
- size_t len = wLent * uChSize();
+ 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;
+ if (len > gTempBuffArraySize) {
+ wBufPtr = new char[len];
+ if (wBufPtr == NULL)
+ return 0;
+ wideCharBuf = wBufPtr;
+ } else
+ wideCharBuf = tmpWBuff;
} else
- wideCharBuf = (char *) toFill;
+ wideCharBuf = (char *) toFill;
- size_t flen = strlen(toTranscode); // wLent;
- char *ptr = wideCharBuf;
- size_t rc = iconvFrom(toTranscode, &flen, &ptr, len);
+ 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 (wBufPtr)
+ delete [] wBufPtr;
+ return false;
}
if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER)
- mbsToXML (wideCharBuf, wLent, toFill, wLent);
+ mbsToXML (wideCharBuf, wLent, toFill, wLent);
if (wBufPtr)
- delete [] wBufPtr;
+ delete [] wBufPtr;
toFill[wLent] = 0x00;
return true;
@@ -1016,10 +1019,10 @@
// ---------------------------------------------------------------------------
-IconvGNULCPTranscoder::IconvGNULCPTranscoder (iconv_t cd_from,
- iconv_t cd_to,
- size_t uchsize,
- unsigned int ubo)
+IconvGNULCPTranscoder::IconvGNULCPTranscoder (iconv_t cd_from,
+ iconv_t cd_to,
+ size_t uchsize,
+ unsigned int ubo)
: IconvGNUWrapper (cd_from, cd_to, uchsize, ubo)
{
}
@@ -1033,12 +1036,12 @@
// ---------------------------------------------------------------------------
// 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
+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)
@@ -1049,19 +1052,19 @@
{
ICONV_LOCK;
if (cdTo() != (iconv_t)-1) {
- iconv_close (cdTo());
- setCDTo ((iconv_t)-1);
+ iconv_close (cdTo());
+ setCDTo ((iconv_t)-1);
}
if (cdFrom() != (iconv_t)-1) {
- iconv_close (cdFrom());
- setCDFrom ((iconv_t)-1);
+ iconv_close (cdFrom());
+ setCDFrom ((iconv_t)-1);
}
}
// ---------------------------------------------------------------------------
// IconvGNUTranscoder: Implementation of the virtual transcoder API
// ---------------------------------------------------------------------------
-unsigned int IconvGNUTranscoder::transcodeFrom
+unsigned int IconvGNUTranscoder::transcodeFrom
(
const XMLByte* const srcData
, const unsigned int srcCount
@@ -1074,92 +1077,92 @@
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();
+ 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;
+ if (len > gTempBuffArraySize) {
+ wBufPtr = new char[len];
+ if (wBufPtr == NULL)
+ return 0;
+ startTarget = wBufPtr;
+ } else
+ startTarget = tmpWBuff;
} else
- startTarget = (char *) toFill;
+ startTarget = (char *) toFill;
// Do character-by-character transcoding
- char *orgTarget = startTarget;
- size_t srcLen = srcCount;
- size_t prevSrcLen = srcLen;
+ 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++;
+ 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);
+ mbsToXML (startTarget, toReturn, toFill, toReturn);
if (wBufPtr)
- delete [] wBufPtr;
+ delete [] wBufPtr;
return toReturn;
}
-unsigned int IconvGNUTranscoder::transcodeTo
+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 )
+ 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();
+ 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);
+ 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;
+ startSrc = (char *) srcData;
- char* startTarget = (char *) toFill;
- size_t srcLen = len;
- size_t rc = iconvTo (startSrc, &srcLen, &startTarget, maxBytes);
+ 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);
+ if (wBufPtr)
+ delete [] wBufPtr;
+ ThrowXML(TranscodingException, XMLExcepts::Trans_BadSrcSeq);
}
charsEaten = srcCount - srcLen / uChSize();
if (wBufPtr)
- delete [] wBufPtr;
+ delete [] wBufPtr;
return startTarget - (char *)toFill;
}
-bool IconvGNUTranscoder::canTranscodeTo
+bool IconvGNUTranscoder::canTranscodeTo
(
const unsigned int toCheck
) const
@@ -1168,21 +1171,21 @@
// 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;
+ 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);
+ 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;
+ 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);
+ size_t rc = iconvTo( srcBuf, &len, &pTmpBuf, 64);
return (rc != (size_t)-1) && (len == 0);
}
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
