tng 2002/12/31 10:42:43
Modified: c/src/xercesc/util/Transcoders/IconvFBSD
IconvFBSDTransService.cpp
Log:
[Bug 15608] IconvLCPTranscoder::transcode() is wrong at wcstombs() usage.
Revision Changes Path
1.7 +577 -569
xml-xerces/c/src/xercesc/util/Transcoders/IconvFBSD/IconvFBSDTransService.cpp
Index: IconvFBSDTransService.cpp
===================================================================
RCS file:
/home/cvs/xml-xerces/c/src/xercesc/util/Transcoders/IconvFBSD/IconvFBSDTransService.cpp,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -r1.6 -r1.7
--- IconvFBSDTransService.cpp 4 Nov 2002 15:14:34 -0000 1.6
+++ IconvFBSDTransService.cpp 31 Dec 2002 18:42:43 -0000 1.7
@@ -56,6 +56,9 @@
/*
* $Log$
+ * Revision 1.7 2002/12/31 18:42:43 tng
+ * [Bug 15608] IconvLCPTranscoder::transcode() is wrong at wcstombs() usage.
+ *
* Revision 1.6 2002/11/04 15:14:34 tng
* C++ Namespace Support.
*
@@ -106,22 +109,22 @@
// Description of encoding schemas, supported by iconv()
// ---------------------------------------------------------------------------
typedef struct __IconvFBSDEncoding {
- 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
} IconvFBSDEncoding;
-static const IconvFBSDEncoding gIconvFBSDEncodings[] = {
- { "ucs-2-internal", 2, LITTLE_ENDIAN },
- { "ucs2-internal", 2, LITTLE_ENDIAN },
- { "ucs-4-internal", 4, LITTLE_ENDIAN },
- { "ucs4-internal", 4, LITTLE_ENDIAN },
- { "UNICODELITTLE", 2, LITTLE_ENDIAN },
- { "UNICODEBIG", 2, BIG_ENDIAN },
- { "iso-10646-ucs-2", 4, BIG_ENDIAN },
- { "iso-10646-ucs-4", 4, BIG_ENDIAN },
- /* { "iso-10646-utf-16", 2, BIG_ENDIAN }, */
- { NULL, 0, 0 }
+static const IconvFBSDEncoding gIconvFBSDEncodings[] = {
+ { "ucs-2-internal", 2, LITTLE_ENDIAN },
+ { "ucs2-internal", 2, LITTLE_ENDIAN },
+ { "ucs-4-internal", 4, LITTLE_ENDIAN },
+ { "ucs4-internal", 4, LITTLE_ENDIAN },
+ { "UNICODELITTLE", 2, LITTLE_ENDIAN },
+ { "UNICODEBIG", 2, BIG_ENDIAN },
+ { "iso-10646-ucs-2", 4, BIG_ENDIAN },
+ { "iso-10646-ucs-4", 4, BIG_ENDIAN },
+ /* { "iso-10646-utf-16", 2, BIG_ENDIAN }, */
+ { NULL, 0, 0 }
};
//--------------------------------------------------
@@ -130,59 +133,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 */
#else /* !XML_USE_LIBICONV */
@@ -209,8 +212,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
};
@@ -291,9 +294,9 @@
static wint_t fbsd_towupper(wint_t ch)
{
if (ch <= 0x7F)
- return toupper(ch);
- unsigned char buf[16];
- wchar_t wc = wchar_t(ch);
+ return toupper(ch);
+ unsigned char buf[16];
+ wchar_t wc = wchar_t(ch);
wcstombs((char*)buf, &wc, 16);
return toupper(*buf);
}
@@ -301,9 +304,9 @@
static wint_t fbsd_towlower(wint_t ch)
{
if (ch <= 0x7F)
- return tolower(ch);
- unsigned char buf[16];
- wchar_t wc = wchar_t(ch);
+ return tolower(ch);
+ unsigned char buf[16];
+ wchar_t wc = wchar_t(ch);
wcstombs((char *)buf, &wc, 16);
return tolower(*buf);
}
@@ -314,8 +317,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 */
@@ -334,15 +337,15 @@
{
}
-IconvFBSDCD::IconvFBSDCD ( iconv_t cd_from,
- iconv_t cd_to,
- size_t uchsize,
- unsigned int ubo )
+IconvFBSDCD::IconvFBSDCD ( 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);
}
}
@@ -351,66 +354,66 @@
}
// Convert "native unicode" character into XMLCh
-void IconvFBSDCD::mbcToXMLCh (const char *mbc, XMLCh *toRet) const
+void IconvFBSDCD::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 IconvFBSDCD::xmlChToMbc (XMLCh xch, char *mbc) const
+void IconvFBSDCD::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 IconvFBSDCD::toUpper (const XMLCh ch) const
+XMLCh IconvFBSDCD::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, (const char**) &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;
@@ -418,31 +421,31 @@
bLen = fUChSize;
ptr = tmpArr;
if (::iconv (fCDFrom, (const char **)&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 IconvFBSDCD::toLower (const XMLCh ch) const
+XMLCh IconvFBSDCD::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, (const char**) &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;
@@ -450,130 +453,130 @@
bLen = fUChSize;
ptr = tmpArr;
if (::iconv (fCDFrom, (const char **)&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 IconvFBSDCD::isSpace(const XMLCh toCheck) const
+bool IconvFBSDCD::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, (const char**) &ptr, &len,
- &pTmpArr, &bLen) == (size_t) -1)
- return 0;
+ ICONV_LOCK;
+ if (::iconv (fCDTo, (const char**) &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* IconvFBSDCD::mbsToXML
+XMLCh* IconvFBSDCD::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* IconvFBSDCD::xmlToMbs
+char* IconvFBSDCD::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 IconvFBSDCD::iconvFrom ( const char *fromPtr,
- size_t *fromLen,
- char **toPtr,
- size_t toLen ) const
+size_t IconvFBSDCD::iconvFrom ( const char *fromPtr,
+ size_t *fromLen,
+ char **toPtr,
+ size_t toLen ) const
{
ICONV_LOCK;
return ::iconv (fCDFrom, &fromPtr, fromLen, toPtr, &toLen);
}
-size_t IconvFBSDCD::iconvTo ( const char *fromPtr,
- size_t *fromLen,
- char **toPtr,
- size_t toLen ) const
+size_t IconvFBSDCD::iconvTo ( const char *fromPtr,
+ size_t *fromLen,
+ char **toPtr,
+ size_t toLen ) const
{
ICONV_LOCK;
return ::iconv (fCDTo, &fromPtr, fromLen, toPtr, &toLen);
@@ -595,72 +598,72 @@
#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 IconvFBSDEncoding *eptr;
+ const IconvFBSDEncoding *eptr;
// first - try to use the schema with character size, equil to XMLCh
for (eptr = gIconvFBSDEncodings; 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 = gIconvFBSDEncodings; 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 = gIconvFBSDEncodings; 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);
}
#endif /* XML_USE_LIBICONV */
@@ -668,12 +671,12 @@
{
#ifdef XML_USE_LIBICONV
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);
}
#endif /* XML_USE_LIBICONV */
}
@@ -681,8 +684,8 @@
// ---------------------------------------------------------------------------
// IconvFBSDTransService: The virtual transcoding service API
// ---------------------------------------------------------------------------
-int IconvFBSDTransService::compareIString(const XMLCh* const comp1
- , const XMLCh* const comp2)
+int IconvFBSDTransService::compareIString(const XMLCh* const comp1
+ , const XMLCh* const comp2)
{
const XMLCh* cptr1 = comp1;
const XMLCh* cptr2 = comp2;
@@ -701,13 +704,13 @@
#else /* XML_USE_LIBICONV */
- 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 );
@@ -716,9 +719,9 @@
}
-int IconvFBSDTransService::compareNIString(const XMLCh* const comp1
- , const XMLCh* const comp2
- , const unsigned int maxChars)
+int IconvFBSDTransService::compareNIString(const XMLCh* const comp1
+ , const XMLCh* const comp2
+ , const unsigned int maxChars)
{
unsigned int n = 0;
const XMLCh* cptr1 = comp1;
@@ -753,10 +756,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
@@ -790,9 +793,9 @@
{
#ifndef XML_USE_LIBICONV
if (toCheck <= 0x7F)
- return isspace(toCheck);
+ return isspace(toCheck);
char buf[16];
- wchar_t wc = wchar_t(toCheck);
+ wchar_t wc = wchar_t(toCheck);
wcstombs( buf, &wc, 16 );
return (isspace(*buf) != 0);
#else /* XML_USE_LIBICONV */
@@ -822,9 +825,9 @@
XMLTranscoder*
IconvFBSDTransService::makeNewXMLTranscoder
(
- const XMLCh* const encodingName
- , XMLTransService::Codes& resValue
- , const unsigned int blockSize
+ const XMLCh* const encodingName
+ , XMLTransService::Codes& resValue
+ , const unsigned int blockSize
)
{
#ifndef XML_USE_LIBICONV
@@ -841,37 +844,37 @@
#else /* XML_USE_LIBICONV */
resValue = XMLTransService::UnsupportedEncoding;
- IconvFBSDTranscoder *newTranscoder = NULL;
+ IconvFBSDTranscoder *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 IconvFBSDTranscoder (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 IconvFBSDTranscoder (encodingName,
+ blockSize,
+ cd_from, cd_to,
+ uChSize(), UBO());
}
if (newTranscoder)
- resValue = XMLTransService::Ok;
+ resValue = XMLTransService::Ok;
if (encLocal)
- delete [] encLocal;
+ delete [] encLocal;
return newTranscoder;
#endif /* !XML_USE_LIBICONV */
@@ -885,7 +888,7 @@
#ifndef XML_USE_LIBICONV
*outPtr = fbsd_towupper(*outPtr);
#else /* XML_USE_LIBICONV */
- *outPtr = toUpper(*outPtr);
+ *outPtr = toUpper(*outPtr);
#endif /* !XML_USE_LIBICONV */
outPtr++;
}
@@ -899,7 +902,7 @@
#ifndef XML_USE_LIBICONV
*outPtr = fbsd_towlower(*outPtr);
#else /* XML_USE_LIBICONV */
- *outPtr = toLower(*outPtr);
+ *outPtr = toLower(*outPtr);
#endif /* !XML_USE_LIBICONV */
outPtr++;
}
@@ -928,21 +931,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();
@@ -977,50 +980,50 @@
const unsigned int retVal = fbsd_wcstombs(NULL, wideCharBuf, 0);
if (allocatedArray)
- delete [] allocatedArray;
+ delete [] allocatedArray;
if (retVal == ~0)
return 0;
return retVal;
#else /* XML_USE_LIBICONV */
- 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;
#endif /* !XML_USE_LIBICONV */
@@ -1054,73 +1057,73 @@
// Calc the needed size.
const size_t neededLen = fbsd_wcstombs(NULL, wideCharBuf, 0);
if (neededLen == -1) {
- if (allocatedArray)
- delete [] allocatedArray;
+ if (allocatedArray)
+ delete [] allocatedArray;
return 0;
- }
-
+ }
+
retVal = new char[neededLen + 1];
fbsd_wcstombs(retVal, wideCharBuf, neededLen);
- if (allocatedArray)
- delete [] allocatedArray;
+ if (allocatedArray)
+ delete [] allocatedArray;
retVal[neededLen] = 0;
#else /* XML_USE_LIBICONV */
// 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, &wLent, &ptr, neededLen);
- if (rc == (size_t)-1) {
- if (wBufPtr)
- delete [] wBufPtr;
- return 0;
- }
- if (wBufPtr)
- delete [] wBufPtr;
+ // 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;
#endif /* !XML_USE_LIBICONV */
} else {
retVal = new char[1];
- if (retVal == NULL)
- return 0;
+ if (retVal == NULL)
+ return 0;
retVal[0] = 0;
}
return retVal;
}
-bool IconvFBSDLCPTranscoder::transcode( const XMLCh* const toTranscode
- , char* const toFill
- , const unsigned int maxBytes)
+bool IconvFBSDLCPTranscoder::transcode( const XMLCh* const toTranscode
+ , char* const toFill
+ , const unsigned int maxBytes)
{
// Watch for a couple of pyscho corner cases
if (!toTranscode || !maxBytes) {
@@ -1136,6 +1139,8 @@
if (wLent > maxBytes)
wLent = maxBytes;
+ size_t mblen;
+
#ifndef XML_USE_LIBICONV
wchar_t tmpWideCharArr[gTempBuffArraySize];
@@ -1152,49 +1157,52 @@
wideCharBuf[wLent] = 0x00;
// Ok, go ahead and try the transcoding. If it fails, then ...
- if (fbsd_wcstombs(toFill, wideCharBuf, maxBytes) == -1) {
- if (allocatedArray)
- delete [] allocatedArray;
+ mblen = fbsd_wcstombs(toFill, wideCharBuf, maxBytes);
+ if (mblen == -1) {
+ if (allocatedArray)
+ delete [] allocatedArray;
return false;
}
if (allocatedArray)
- delete [] allocatedArray;
+ delete [] allocatedArray;
#else /* XML_USE_LIBICONV */
// 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);
- } else
- wideCharBuf = (char *) toTranscode;
+ 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;
+ char *ptr = toFill;
+ mblen = iconvTo(wideCharBuf, &len, &ptr, maxBytes);
+ if (mblen == (size_t)-1) {
+ if (wBufPtr)
+ delete [] wBufPtr;
+ return false;
}
if (wBufPtr)
- delete [] wBufPtr;
+ delete [] wBufPtr;
#endif /* !XML_USE_LIBICONV */
// Cap it off just in case
- toFill[wLent] = 0;
+ toFill[mblen] = 0;
return true;
}
@@ -1227,68 +1235,68 @@
fbsd_mbstowcs(wideCharBuf, toTranscode, wLent);
retVal = new XMLCh[wLent + 1];
- if (retVal == NULL) {
- if (allocatedArray)
- delete [] allocatedArray;
- return NULL;
- }
+ if (retVal == NULL) {
+ if (allocatedArray)
+ delete [] allocatedArray;
+ return NULL;
+ }
for (unsigned int i = 0; i < wLent; i++)
retVal[i] = (XMLCh) wideCharBuf[i];
retVal[wLent] = 0x00;
- if (allocatedArray)
- delete [] allocatedArray;
+ if (allocatedArray)
+ delete [] allocatedArray;
#else /* XML_USE_LIBICONV */
- 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;
-
+
#endif /* !XML_USE_LIBICONV */
}
else {
retVal = new XMLCh[1];
- if (retVal == NULL )
- return 0;
+ if (retVal == NULL )
+ return 0;
retVal[0] = 0;
}
return retVal;
}
-bool IconvFBSDLCPTranscoder::transcode(const char* const toTranscode
- , XMLCh* const toFill
- , const unsigned int maxChars)
+bool IconvFBSDLCPTranscoder::transcode(const char* const toTranscode
+ , XMLCh* const toFill
+ , const unsigned int maxChars)
{
// Check for a couple of psycho corner cases
if (!toTranscode || !maxChars)
@@ -1319,46 +1327,46 @@
wideCharBuf = tmpWideCharArr;
if (fbsd_mbstowcs(wideCharBuf, toTranscode, wLent) == -1) {
- if (allocatedArray)
- delete [] allocatedArray;
+ if (allocatedArray)
+ delete [] allocatedArray;
return false;
}
for (unsigned int i = 0; i < wLent; i++)
toFill[i] = (XMLCh) wideCharBuf[i];
if (allocatedArray)
- delete [] allocatedArray;
+ delete [] allocatedArray;
#else /* XML_USE_LIBICONV */
- 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;
#endif /* !XML_USE_LIBICONV */
@@ -1373,10 +1381,10 @@
#ifdef XML_USE_LIBICONV
-IconvFBSDLCPTranscoder::IconvFBSDLCPTranscoder (iconv_t cd_from,
- iconv_t cd_to,
- size_t uchsize,
- unsigned int ubo)
+IconvFBSDLCPTranscoder::IconvFBSDLCPTranscoder (iconv_t cd_from,
+ iconv_t cd_to,
+ size_t uchsize,
+ unsigned int ubo)
: IconvFBSDCD (cd_from, cd_to, uchsize, ubo)
{
}
@@ -1402,12 +1410,12 @@
// ---------------------------------------------------------------------------
// IconvFBSDTranscoder: Constructors and Destructor
// ---------------------------------------------------------------------------
-IconvFBSDTranscoder::IconvFBSDTranscoder (const XMLCh* const encodingName
- , const unsigned int blockSize
- , iconv_t cd_from
- , iconv_t cd_to
- , size_t uchsize
- , unsigned int ubo
+IconvFBSDTranscoder::IconvFBSDTranscoder (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)
, IconvFBSDCD (cd_from, cd_to, uchsize, ubo)
@@ -1418,19 +1426,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);
}
}
// ---------------------------------------------------------------------------
// IconvFBSDTranscoder: Implementation of the virtual transcoder API
// ---------------------------------------------------------------------------
-unsigned int IconvFBSDTranscoder::transcodeFrom
+unsigned int IconvFBSDTranscoder::transcodeFrom
(
const XMLByte* const srcData
, const unsigned int srcCount
@@ -1443,92 +1451,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 IconvFBSDTranscoder::transcodeTo
+unsigned int IconvFBSDTranscoder::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 IconvFBSDTranscoder::canTranscodeTo
+bool IconvFBSDTranscoder::canTranscodeTo
(
const unsigned int toCheck
) const
@@ -1537,21 +1545,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]
