// ---------------------------------------------------------------------------
// IconvGNULCPTranscoder: The virtual transcoder API
// ---------------------------------------------------------------------------
XMLSize_t IconvGNULCPTranscoder::calcRequiredSize (const char* const srcText
, MemoryManager* const manager)
{
if (!srcText)
return 0;
size_t len, srcLen;
len = srcLen = strlen(srcText);
if (len == 0)
return 0;
char tmpWideArr[gTempBuffArraySize];
size_t totalLen = 0;
XMLMutexLock lockConverter(&fMutex);
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) {
ThrowXMLwithMemMgr(TranscodingException, XMLExcepts::Trans_BadSrcSeq, manager);
/* return 0; */
}
rc = pTmpArr - (char *) tmpWideArr;
totalLen += rc;
if (rc == 0 || len == 0)
break;
}
return totalLen / uChSize();
}
bool Iconv390LCPTranscoder::transcode( const char* const toTranscode
, XMLCh* const toFill
, const unsigned int maxChars
, MemoryManager* const manager)
{
// 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 retCode;
char *tmpInPtr = (char*) toTranscode;
char *tmpOutPtr = (char*) toFill;
size_t inByteLeft = maxChars;
size_t outByteLeft = maxChars*2;
{
XMLMutexLock lockConverter(&converter->fMutex);
retCode = iconv(converter->fIconv390Descriptor, &tmpInPtr, &inByteLeft, &tmpOutPtr, &outByteLeft);
}
if ( (retCode == -1) && (outByteLeft!=0) ) {
return false;
}
toFill[maxChars] = 0x00;
return true;
}
int IconvGNUTransService::compareNIString(const XMLCh* const comp1
, const XMLCh* const comp2
, const XMLSize_t maxChars)
{
unsigned int n = 0;
const XMLCh* cptr1 = comp1;
const XMLCh* cptr2 = comp2;
XMLMutexLock lockConverter(&fMutex);
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;
}
bool IconvGNULCPTranscoder::transcode(const char* const toTranscode
, XMLCh* const toFill
, const XMLSize_t maxChars
, MemoryManager* const manager)
{
// Check for a couple of psycho corner cases
if (!toTranscode || !maxChars)
{
toFill[0] = 0;
return true;
}
if (!*toTranscode)
{
toFill[0] = 0;
return true;
}
XMLSize_t wLent = calcRequiredSize(toTranscode);
if (wLent > maxChars)
wLent = maxChars;
char tmpWBuff[gTempBuffArraySize];
char *wideCharBuf = 0;
char *wBufPtr = 0;
ArrayJanitor<char> janBuf(wBufPtr, manager);
size_t len = wLent * uChSize();
if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
if (len > gTempBuffArraySize) {
wBufPtr = (char*) manager->allocate(len * sizeof(char));//new char[len];
janBuf.reset(wBufPtr, manager);
wideCharBuf = wBufPtr;
} else
wideCharBuf = tmpWBuff;
} else
wideCharBuf = (char *) toFill;
size_t flen = strlen(toTranscode); // wLent;
char *ptr = wideCharBuf;
size_t rc;
{
XMLMutexLock lockConverter(&fMutex);
rc = iconvFrom(toTranscode, &flen, &ptr, len);
}
if (rc == (size_t)-1) {
return false;
}
if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER)
mbsToXML (wideCharBuf, toFill, wLent);
toFill[wLent] = 0x00;
return true;
}
XMLCh* IconvGNULCPTranscoder::transcode(const char* const toTranscode,
MemoryManager* const manager)
{
if (!toTranscode)
return 0;
XMLCh* retVal = 0;
if (!*toTranscode) {
retVal = (XMLCh*) manager->allocate(sizeof(XMLCh));//new XMLCh[1];
retVal[0] = 0;
return retVal;
}
XMLSize_t wLent = calcRequiredSize(toTranscode, manager);
if (wLent == 0) {
retVal = (XMLCh*) manager->allocate(sizeof(XMLCh));//new XMLCh[1];
retVal[0] = 0;
return retVal;
}
char tmpWBuff[gTempBuffArraySize];
char *wideCharBuf = 0;
char *wBufPtr = 0;
ArrayJanitor<char> janBuf(wBufPtr, manager);
size_t len = wLent * uChSize();
retVal = (XMLCh*) manager->allocate((wLent + 1) * sizeof(XMLCh));//new XMLCh[wLent + 1];
if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
if (len > gTempBuffArraySize) {
wBufPtr = (char*) manager->allocate(len * sizeof(char));//new char[len];
janBuf.reset(wBufPtr, manager);
wideCharBuf = wBufPtr;
} else
wideCharBuf = tmpWBuff;
} else
wideCharBuf = (char *) retVal;
size_t flen = strlen(toTranscode);
char *ptr = wideCharBuf;
size_t rc;
{
XMLMutexLock lockConverter(&fMutex);
rc = iconvFrom(toTranscode, &flen, &ptr, len);
}
if (rc == (size_t) -1) {
return NULL;
}
if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER)
mbsToXML (wideCharBuf, retVal, wLent);
retVal[wLent] = 0x00;
return retVal;
}
char* IconvGNULCPTranscoder::transcode(const XMLCh* const toTranscode,
MemoryManager* const manager)
{
if (!toTranscode)
return 0;
char* retVal = 0;
if (!*toTranscode) {
retVal = (char*) manager->allocate(sizeof(char));//new char[1];
retVal[0] = 0;
return retVal;
}
XMLSize_t wLent = getWideCharLength(toTranscode);
// Calc needed size.
XMLSize_t neededLen = calcRequiredSize (toTranscode, manager);
if (neededLen == 0)
return 0;
// allocate output buffer
retVal = (char*) manager->allocate((neededLen + 1) * sizeof(char));//new char[neededLen + 1];
// prepare the original
char tmpWBuff[gTempBuffArraySize];
char *wideCharBuf = 0;
char *wBufPtr = 0;
ArrayJanitor<char> janBuf(wBufPtr, manager);
size_t len = wLent * uChSize();
if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
if (len > gTempBuffArraySize) {
wBufPtr = (char*) manager->allocate(len * sizeof(char));//new char[len];
janBuf.reset(wBufPtr, manager);
wideCharBuf = wBufPtr;
} else
wideCharBuf = tmpWBuff;
xmlToMbs (toTranscode, wideCharBuf, wLent);
} else
wideCharBuf = (char *) toTranscode;
// perform conversion
char* ptr = retVal;
size_t rc;
{
XMLMutexLock lockConverter(&fMutex);
rc = iconvTo(wideCharBuf, &len, &ptr, neededLen);
}
if (rc == (size_t)-1) {
return 0;
}
retVal[neededLen] = 0;
return retVal;
}
// ---------------------------------------------------------------------------
// IconvGNUTranscoder: Implementation of the virtual transcoder API
// ---------------------------------------------------------------------------
XMLSize_t IconvGNUTranscoder::transcodeFrom
(
const XMLByte* const srcData
, const XMLSize_t srcCount
, XMLCh* const toFill
, const XMLSize_t maxChars
, XMLSize_t& 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;
ArrayJanitor<char> janBuf(wBufPtr, getMemoryManager());
size_t len = maxChars * uChSize();
if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
if (len > gTempBuffArraySize) {
wBufPtr = (char*) getMemoryManager()->allocate(len * sizeof(char));//new char[len];
janBuf.reset(wBufPtr, getMemoryManager());
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;
XMLMutexLock lockConverter(&fMutex);
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) {
ThrowXMLwithMemMgr(TranscodingException, XMLExcepts::Trans_BadSrcSeq, getMemoryManager());
}
}
charSizes[cnt] = prevSrcLen - srcLen;
prevSrcLen = srcLen;
bytesEaten += charSizes[cnt];
startSrc = endSrc - srcLen;
toReturn++;
}
if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER)
mbsToXML (startTarget, toFill, toReturn);
return toReturn;
}
bool IconvGNULCPTranscoder::transcode( const XMLCh* const toTranscode
, char* const toFill
, const XMLSize_t maxBytes
, MemoryManager* const manager)
{
// Watch for a couple of pyscho corner cases
if (!toTranscode || !maxBytes) {
toFill[0] = 0;
return true;
}
if (!*toTranscode) {
toFill[0] = 0;
return true;
}
XMLSize_t wLent = getWideCharLength(toTranscode);
if (wLent > maxBytes)
wLent = maxBytes;
// Fill the "unicode" string
char tmpWBuff[gTempBuffArraySize];
char *wideCharBuf = 0;
char *wBufPtr = 0;
ArrayJanitor<char> janBuf(wBufPtr, manager);
size_t len = wLent * uChSize();
if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
if (len > gTempBuffArraySize) {
wBufPtr = (char*) manager->allocate(len * sizeof(char));//new char[len];
janBuf.reset(wBufPtr, manager);
wideCharBuf = wBufPtr;
} else
wideCharBuf = tmpWBuff;
xmlToMbs (toTranscode, wideCharBuf, wLent);
} else
wideCharBuf = (char *) toTranscode;
// Ok, go ahead and try the transcoding. If it fails, then ...
char *ptr = toFill;
size_t rc;
{
XMLMutexLock lockConverter(&fMutex);
rc = iconvTo(wideCharBuf, &len, &ptr, maxBytes);
}
if (rc == (size_t)-1) {
return false;
}
// Cap it off
*ptr = 0;
return true;
}
void IconvGNUTransService::lowerCase(XMLCh* const toLowerCase)
{
XMLCh* outPtr = toLowerCase;
XMLMutexLock lockConverter(&fMutex);
while (*outPtr)
{
*outPtr = toLower(*outPtr);
outPtr++;
}
}
XMLCh* Iconv390LCPTranscoder::transcode(const char* const toTranscode,
MemoryManager* const manager)
{
if (!toTranscode)
return 0;
XMLCh* retVal = 0;
if (*toTranscode)
{
const unsigned int len = calcRequiredSize(toTranscode, manager);
if (len == 0)
{
retVal = (XMLCh*) manager->allocate(sizeof(XMLCh));//new XMLCh[1];
retVal[0] = 0;
return retVal;
}
wchar_t tmpWideCharArr[gTempBuffArraySize];
wchar_t* allocatedArray = 0;
wchar_t* wideCharBuf = 0;
retVal = (XMLCh*) manager->allocate((len + 1) * sizeof(XMLCh));//new XMLCh[len + 1];
size_t retCode;
char *tmpInPtr = (char*) toTranscode;
char *tmpOutPtr = (char*) retVal;
size_t inByteLeft = len;
size_t outByteLeft = len*2;
{
XMLMutexLock lockConverter(&converter->fMutex);
retCode = iconv(converter->fIconv390Descriptor, &tmpInPtr, &inByteLeft, &tmpOutPtr, &outByteLeft);
}
if (retCode == -1) {
manager->deallocate(retVal);//delete [] retVal;
return 0;
}
retVal[len] = 0x00;
manager->deallocate(allocatedArray);//delete [] allocatedArray;
}
else
{
retVal = (XMLCh*) manager->allocate(sizeof(XMLCh));//new XMLCh[1];
retVal[0] = 0;
}
return retVal;
}
XMLSize_t IconvGNULCPTranscoder::calcRequiredSize(const XMLCh* const srcText
, MemoryManager* const manager)
{
if (!srcText)
return 0;
XMLSize_t wLent = getWideCharLength(srcText);
if (wLent == 0)
return 0;
char tmpWBuff[gTempBuffArraySize];
char *wBuf = 0;
char *wBufPtr = 0;
ArrayJanitor<char> janBuf(wBufPtr, manager);
size_t len = wLent * uChSize();
if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
if (len > gTempBuffArraySize) {
wBufPtr = (char*) manager->allocate(len * sizeof(char));//new char[len];
janBuf.reset(wBufPtr, manager);
wBuf = wBufPtr;
} else
wBuf = tmpWBuff;
xmlToMbs (srcText, wBuf, wLent);
} else
wBuf = (char *) srcText;
char tmpBuff[gTempBuffArraySize];
size_t totalLen = 0;
char *srcEnd = wBuf + wLent * uChSize();
XMLMutexLock lockConverter(&fMutex);
for (;;) {
char *pTmpArr = tmpBuff;
const char *ptr = srcEnd - len;
size_t rc = iconvTo(ptr, &len, &pTmpArr, gTempBuffArraySize);
if (rc == (size_t) -1 && errno != E2BIG) {
ThrowXMLwithMemMgr(TranscodingException, XMLExcepts::Trans_BadSrcSeq, manager);
/* return 0; */
}
rc = pTmpArr - tmpBuff;
totalLen += rc;
if (rc == 0 || len == 0)
break;
}
return totalLen;
}
// ---------------------------------------------------------------------------
// 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;
XMLMutexLock lockConverter(&fMutex);
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 );
}
XMLSize_t IconvGNUTranscoder::transcodeTo
(
const XMLCh* const srcData
, const XMLSize_t srcCount
, XMLByte* const toFill
, const XMLSize_t maxBytes
, XMLSize_t& charsEaten
, const UnRepOpts /*options*/ )
{
// Transcode FROM XMLCh
char tmpWBuff[gTempBuffArraySize];
char *startSrc = tmpWBuff;
char *wBufPtr = 0;
ArrayJanitor<char> janBuf(wBufPtr, getMemoryManager());
size_t len = srcCount * uChSize();
if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
if (len > gTempBuffArraySize) {
wBufPtr = (char*) getMemoryManager()->allocate(len * sizeof(char));//new char[len];
janBuf.reset(wBufPtr, getMemoryManager());
startSrc = wBufPtr;
} else
startSrc = tmpWBuff;
xmlToMbs (srcData, startSrc, srcCount);
} else
startSrc = (char *) srcData;
char* startTarget = (char *) toFill;
size_t srcLen = len;
size_t rc;
{
XMLMutexLock lockConverter(&fMutex);
rc = iconvTo (startSrc, &srcLen, &startTarget, maxBytes);
}
if (rc == (size_t)-1 && errno != E2BIG) {
ThrowXMLwithMemMgr(TranscodingException, XMLExcepts::Trans_BadSrcSeq, getMemoryManager());
}
charsEaten = srcCount - srcLen / uChSize();
return startTarget - (char *)toFill;
}
