XERCES_CPP_NAMESPACE_BEGIN
LocalFileFormatTarget::LocalFileFormatTarget( const XMLCh* const fileName
, MemoryManager* const manager)
: fSource(0)
, fDataBuf(0)
, fIndex(0)
, fCapacity(1023)
, fMemoryManager(manager)
{
fSource = XMLPlatformUtils::openFileToWrite(fileName, manager);
if (!fSource)
ThrowXMLwithMemMgr1(IOException, XMLExcepts::File_CouldNotOpenFile, fileName, fMemoryManager);
// Buffer is one larger than capacity, to allow for zero term
fDataBuf = (XMLByte*) fMemoryManager->allocate
(
(fCapacity+4) * sizeof(XMLByte)
);//new XMLByte[fCapacity+4];
// Keep it null terminated
fDataBuf[0] = XMLByte(0);
}
void setBit(const unsigned int bitToSet)
{
if (bitToSet >= fBitCount)
ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Bitset_BadIndex, fMemoryManager);
if (fBitCount < 65)
{
const unsigned int mask = (0x1UL << (bitToSet % 32));
if (bitToSet < 32)
{
fBits1 &= ~mask;
fBits1 |= mask;
}
else
{
fBits2 &= ~mask;
fBits2 |= mask;
}
}
else
{
// Create the mask and byte values
const XMLByte mask1 = XMLByte(0x1 << (bitToSet % 8));
const unsigned int byteOfs = bitToSet >> 3;
// And access the right bit and byte
fByteArray[byteOfs] &= ~mask1;
fByteArray[byteOfs] |= mask1;
}
}
unsigned int
XMLASCIITranscoder::transcodeTo(const XMLCh* const srcData
, const unsigned int srcCount
, XMLByte* const toFill
, const unsigned int maxBytes
, unsigned int& charsEaten
, const UnRepOpts options)
{
// If debugging, make sure that the block size is legal
#if defined(XERCES_DEBUG)
checkBlockSize(maxBytes);
#endif
//
// Calculate the max chars we can do here. Its the lesser of the
// max output chars and the source byte count.
//
const unsigned int countToDo = srcCount < maxBytes ? srcCount : maxBytes;
const XMLCh* srcPtr = srcData;
XMLByte* outPtr = toFill;
for (unsigned int index = 0; index < countToDo; index++)
{
// If its legal, do it and jump back to the top
if (*srcPtr < 0x80)
{
*outPtr++ = XMLByte(*srcPtr++);
continue;
}
//
// Its not representable so use a replacement char. According to
// the options, either throw or use the replacement.
//
if (options == UnRep_Throw)
{
XMLCh tmpBuf[17];
XMLString::binToText((unsigned int)*srcPtr, tmpBuf, 16, 16, getMemoryManager());
ThrowXMLwithMemMgr2
(
TranscodingException
, XMLExcepts::Trans_Unrepresentable
, tmpBuf
, getEncodingName()
, getMemoryManager()
);
}
// Use the replacement char
*outPtr++ = 0x1A;
srcPtr++;
}
// Set the chars we ate
charsEaten = countToDo;
// Return the byte we transcoded
return countToDo;
}
XMLSize_t
XML88591Transcoder::transcodeTo(const XMLCh* const srcData
, const XMLSize_t srcCount
, XMLByte* const toFill
, const XMLSize_t maxBytes
, XMLSize_t& charsEaten
, const UnRepOpts options)
{
//
// Calculate the max chars we can do here. Its the lesser of the
// max output bytes and the number of chars in the source.
//
const XMLSize_t countToDo = srcCount < maxBytes ? srcCount : maxBytes;
//
// Loop through the bytes to do and convert over each byte. Its just
// a downcast of the wide char, checking for unrepresentable chars.
//
const XMLCh* srcPtr = srcData;
const XMLCh* srcEnd = srcPtr + countToDo;
XMLByte* destPtr = toFill;
while (srcPtr < srcEnd)
{
// If its legal, take it and jump back to top
if (*srcPtr < 256)
{
*destPtr++ = XMLByte(*srcPtr++);
continue;
}
//
// Its not representable so use a replacement char. According to
// the options, either throw or use the replacement.
//
if (options == UnRep_Throw)
{
XMLCh tmpBuf[17];
XMLString::binToText((unsigned int)*srcPtr, tmpBuf, 16, 16, getMemoryManager());
ThrowXMLwithMemMgr2
(
TranscodingException
, XMLExcepts::Trans_Unrepresentable
, tmpBuf
, getEncodingName()
, getMemoryManager()
);
}
*destPtr++ = 0x1A;
srcPtr++;
}
// Set the chars eaten
charsEaten = countToDo;
// Return the bytes we transcoded
return countToDo;
}
MATCH_CPP_NAMESPACE_BEGIN
MemBufFormatTarget::MemBufFormatTarget( XMLSize_t initCapacity
, MemoryManager* const manager)
: fMemoryManager(manager)
, fDataBuf(0)
, fIndex(0)
, fCapacity(initCapacity)
{
// Buffer is one larger than capacity, to allow for zero term
fDataBuf = (XMLByte*) fMemoryManager->allocate
(
(fCapacity + 4) * sizeof(XMLByte)
);//new XMLByte[fCapacity+4];
// Keep it null terminated
fDataBuf[0] = XMLByte(0);
}
XERCES_CPP_NAMESPACE_BEGIN
BinMemOutputStream::BinMemOutputStream( int initCapacity
, MemoryManager* const manager)
: fMemoryManager(manager)
, fDataBuf(0)
, fIndex(0)
, fCapacity(initCapacity)
{
// Buffer is one larger than capacity, to allow for zero term
fDataBuf = (XMLByte*) fMemoryManager->allocate
(
(fCapacity + 4) * sizeof(XMLByte)
);
// Keep it null terminated
fDataBuf[0] = XMLByte(0);
}
bool getBit(const unsigned int bitToGet) const
{
if (bitToGet >= fBitCount)
ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Bitset_BadIndex, fMemoryManager);
if (fBitCount < 65)
{
unsigned int mask = (0x1UL << (bitToGet % 32));
if (bitToGet < 32)
return ((fBits1 & mask) != 0);
else
return ((fBits2 & mask) != 0);
}
// Create the mask and byte values
const XMLByte mask1 = XMLByte(0x1 << (bitToGet % 8));
const unsigned int byteOfs = bitToGet >> 3;
// And access the right bit and byte
return ((fByteArray[byteOfs] & mask1) != 0);
}
unsigned int
XMLUTF8Transcoder::transcodeTo( const XMLCh* const srcData
, const unsigned int srcCount
, XMLByte* const toFill
, const unsigned int maxBytes
, unsigned int& charsEaten
, const UnRepOpts options)
{
// Watch for pathological scenario. Shouldn't happen, but...
if (!srcCount || !maxBytes)
return 0;
//
// Get pointers to our start and end points of the input and output
// buffers.
//
const XMLCh* srcPtr = srcData;
const XMLCh* srcEnd = srcPtr + srcCount;
XMLByte* outPtr = toFill;
XMLByte* outEnd = toFill + maxBytes;
while (srcPtr < srcEnd)
{
//
// Tentatively get the next char out. We have to get it into a
// 32 bit value, because it could be a surrogate pair.
//
XMLUInt32 curVal = *srcPtr;
//
// If its a leading surrogate, then lets see if we have the trailing
// available. If not, then give up now and leave it for next time.
//
unsigned int srcUsed = 1;
if ((curVal >= 0xD800) && (curVal <= 0xDBFF))
{
if (srcPtr + 1 >= srcEnd)
break;
// Create the composite surrogate pair
curVal = ((curVal - 0xD800) << 10)
+ ((*(srcPtr + 1) - 0xDC00) + 0x10000);
// And indicate that we ate another one
srcUsed++;
}
// Figure out how many bytes we need
unsigned int encodedBytes;
if (curVal < 0x80)
encodedBytes = 1;
else if (curVal < 0x800)
encodedBytes = 2;
else if (curVal < 0x10000)
encodedBytes = 3;
else if (curVal < 0x110000)
encodedBytes = 4;
else
{
// If the options say to throw, then throw
if (options == UnRep_Throw)
{
XMLCh tmpBuf[17];
XMLString::binToText(curVal, tmpBuf, 16, 16, getMemoryManager());
ThrowXMLwithMemMgr2
(
TranscodingException
, XMLExcepts::Trans_Unrepresentable
, tmpBuf
, getEncodingName()
, getMemoryManager()
);
}
// Else, use the replacement character
*outPtr++ = chSpace;
srcPtr += srcUsed;
continue;
}
//
// If we cannot fully get this char into the output buffer,
// then leave it for the next time.
//
if (outPtr + encodedBytes > outEnd)
break;
// We can do it, so update the source index
srcPtr += srcUsed;
//
// And spit out the bytes. We spit them out in reverse order
// here, so bump up the output pointer and work down as we go.
//
outPtr += encodedBytes;
switch(encodedBytes)
{
case 6 : *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL);
curVal >>= 6;
case 5 : *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL);
curVal >>= 6;
case 4 : *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL);
curVal >>= 6;
case 3 : *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL);
curVal >>= 6;
case 2 : *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL);
curVal >>= 6;
case 1 : *--outPtr = XMLByte
(
curVal | gFirstByteMark[encodedBytes]
);
}
// Add the encoded bytes back in again to indicate we've eaten them
outPtr += encodedBytes;
}
// Fill in the chars we ate
charsEaten = (srcPtr - srcData);
// And return the bytes we filled in
return (outPtr - toFill);
}
