Ignore:
Timestamp:
May 3, 2013, 11:28:28 AM (6 years ago)
Author:
cameron
Message:

Initial imports for icXML v0.9

File:
1 edited

Legend:

Unmodified
Added
Removed
  • icXML/icXML-devel/src/icxercesc/util/XMLUCS4Transcoder.cpp

    r2721 r3103  
    138138}
    139139
     140XMLSize_t
     141XMLUCS4Transcoder::transcodeFrom(const  XMLByte* const          srcData
     142                                , const XMLSize_t               srcCount
     143                                ,       XMLCh* const            toFill
     144                                , const XMLSize_t               maxChars
     145                                ,       XMLSize_t&              bytesEaten)
     146{
     147    //
     148    //  Get pointers to the start and end of the source buffer in terms of
     149    //  UCS-4 characters.
     150    //
     151    const UCS4Ch*   srcPtr = (const UCS4Ch*)srcData;
     152    const UCS4Ch*   srcEnd = srcPtr + (srcCount / sizeof(UCS4Ch));
     153
     154    //
     155    //  Get pointers to the start and end of the target buffer, which is
     156    //  in terms of the XMLCh chars we output.
     157    //
     158    XMLCh*  outPtr = toFill;
     159    XMLCh*  outEnd = toFill + maxChars;
     160
     161    //
     162    //  Now process chars until we either use up all our source or all of
     163    //  our output space.
     164    //
     165    while ((outPtr < outEnd) && (srcPtr < srcEnd))
     166    {
     167        //
     168        //  Get the next UCS char out of the buffer. Don't bump the ptr
     169        //  yet since we might not have enough storage for it in the target
     170        //  (if its causes a surrogate pair to be created.
     171        //
     172        UCS4Ch nextVal = *srcPtr;
     173
     174        // If it needs to be swapped, then do it
     175        if (fSwapped)
     176            nextVal = BitOps::swapBytes(nextVal);
     177
     178        // Handle a surrogate pair if needed
     179        if (nextVal & 0xFFFF0000)
     180        {
     181            //
     182            //  If we don't have room for both of the chars, then we
     183            //  bail out now.
     184            //
     185            if (outPtr + 1 == outEnd)
     186                break;
     187
     188            const XMLInt32 LEAD_OFFSET = 0xD800 - (0x10000 >> 10);
     189            const XMLCh ch1 = XMLCh(LEAD_OFFSET + (nextVal >> 10));
     190            const XMLCh ch2 = XMLCh(0xDC00 + (nextVal & 0x3FF));
     191
     192            //
     193            //  We have room so store them both. But note that the
     194            //  second one took up no source bytes!
     195            //
     196            *outPtr++ = ch1;
     197            *outPtr++ = ch2;
     198        }
     199         else
     200        {
     201            //
     202            //  No surrogate, so just store it and bump the count of chars
     203            //  read. Update the char sizes buffer for this char's entry.
     204            //
     205            *outPtr++ = XMLCh(nextVal);
     206        }
     207
     208        // Indicate that we ate another UCS char's worth of bytes
     209        srcPtr++;
     210    }
     211
     212    // Set the bytes eaten parameter
     213    bytesEaten = ((const XMLByte*)srcPtr) - srcData;
     214
     215    // And return the chars written into the output buffer
     216    return outPtr - toFill;
     217}
    140218
    141219XMLSize_t
     
    311389}
    312390
     391bool XMLUCS4Transcoder::isSwapped() const
     392{
     393    return fSwapped;
     394}
     395
     396
    313397XERCES_CPP_NAMESPACE_END
Note: See TracChangeset for help on using the changeset viewer.