source: icXML/icXML-devel/src/icxercesc/util/XMLUTF8Transcoder.cpp

Last change on this file was 3564, checked in by cameron, 6 years ago

Changes to icxercesc files

File size: 39.4 KB
Line 
1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 *      http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18/**
19 * $Id: XMLUTF8Transcoder.cpp 932887 2010-04-11 13:04:59Z borisk $
20 */
21
22// ---------------------------------------------------------------------------
23//  Includes
24// ---------------------------------------------------------------------------
25
26#include <xercesc/util/TranscodingException.hpp>
27#include <icxercesc/util/XMLUTF8Transcoder.hpp>
28#include <xercesc/util/XMLUniDefs.hpp>
29#include <icxercesc/internal/XMLReader.hpp>
30#include <icxercesc/internal/XMLScanner.hpp>
31#include <icxercesc/util/XMLString.hpp>
32
33
34XERCES_CPP_NAMESPACE_BEGIN
35
36// ---------------------------------------------------------------------------
37//  Local static data
38//
39//  gUTFBytes
40//      A list of counts of trailing bytes for each initial byte in the input.
41//
42//  gUTFByteIndicator
43//      For a UTF8 sequence of n bytes, n>=2, the first byte of the
44//      sequence must contain n 1's followed by precisely 1 0 with the
45//      rest of the byte containing arbitrary bits.  This array stores
46//      the required bit pattern for validity checking.
47//  gUTFByteIndicatorTest
48//      When bitwise and'd with the observed value, if the observed
49//      value is correct then a result matching gUTFByteIndicator will
50//      be produced.
51//
52//  gUTFOffsets
53//      A list of values to offset each result char type, according to how
54//      many source bytes when into making it.
55//
56//  gFirstByteMark
57//      A list of values to mask onto the first byte of an encoded sequence,
58//      indexed by the number of bytes used to create the sequence.
59// ---------------------------------------------------------------------------
60static const XMLByte gUTFBytes[256] =
61{
62                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
63        ,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
64        ,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
65        ,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
66        ,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
67        ,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
68        ,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
69        ,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
70        ,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
71        ,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
72        ,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
73        ,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
74        ,   0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
75        ,   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
76        ,   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
77        ,   3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5
78};
79
80static const XMLByte gUTFByteIndicator[6] =
81{
82        0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC
83};
84static const XMLByte gUTFByteIndicatorTest[6] =
85{
86        0x80, 0xE0, 0xF0, 0xF8, 0xFC, 0xFE
87};
88
89static const XMLUInt32 gUTFOffsets[6] =
90{
91        0, 0x3080, 0xE2080, 0x3C82080, 0xFA082080, 0x82082080
92};
93
94static const XMLByte gFirstByteMark[7] =
95{
96        0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC
97};
98
99
100
101// ---------------------------------------------------------------------------
102//  XMLUTF8Transcoder: Constructors and Destructor
103// ---------------------------------------------------------------------------
104XMLUTF8Transcoder::XMLUTF8Transcoder(const  XMLCh* const    encodingName
105                                                                        , const XMLSize_t       blockSize
106                                                                        , MemoryManager* const  manager)
107:XMLTranscoder(encodingName, blockSize, manager)
108{
109}
110
111XMLUTF8Transcoder::~XMLUTF8Transcoder()
112{
113}
114
115
116// ---------------------------------------------------------------------------
117//  XMLUTF8Transcoder: Implementation of the transcoder API
118// ---------------------------------------------------------------------------
119XMLSize_t
120XMLUTF8Transcoder::transcodeFrom( const  XMLByte* const         srcData
121                                                                , const XMLSize_t               srcCount
122                                                                ,       XMLCh* const            toFill
123                                                                , const XMLSize_t               maxChars
124                                                                ,       XMLSize_t&              bytesEaten
125                                                                ,       unsigned char* const    charSizes)
126{
127        // Watch for pathological scenario. Shouldn't happen, but...
128        if (!srcCount || !maxChars)
129                return 0;
130
131        //
132        //  Get pointers to our start and end points of the input and output
133        //  buffers.
134        //
135        const XMLByte*  srcPtr = srcData;
136        const XMLByte*  srcEnd = srcPtr + srcCount;
137        XMLCh*          outPtr = toFill;
138        XMLCh*          outEnd = outPtr + maxChars;
139        unsigned char*  sizePtr = charSizes;
140
141        //
142        //  We now loop until we either run out of input data, or room to store
143        //  output chars.
144        //
145        while ((srcPtr < srcEnd) && (outPtr < outEnd))
146        {
147                // Special-case ASCII, which is a leading byte value of <= 127
148                if (*srcPtr <= 127)
149                {
150                        // Handle ASCII in groups instead of single character at a time.
151                        const XMLByte* srcPtr_save = srcPtr;
152                        const XMLSize_t chunkSize = (srcEnd-srcPtr)<(outEnd-outPtr)?(srcEnd-srcPtr):(outEnd-outPtr);
153                        for(XMLSize_t i=0;i<chunkSize && *srcPtr <= 127;++i)
154                                *outPtr++ = XMLCh(*srcPtr++);
155                        memset(sizePtr,1,srcPtr - srcPtr_save);
156                        sizePtr += srcPtr - srcPtr_save;
157                        if (srcPtr == srcEnd || outPtr == outEnd)
158                                break;
159                }
160
161                // See how many trailing src bytes this sequence is going to require
162                const unsigned int trailingBytes = gUTFBytes[*srcPtr];
163
164                //
165                //  If there are not enough source bytes to do this one, then we
166                //  are done. Note that we done >= here because we are implicitly
167                //  counting the 1 byte we get no matter what.
168                //
169                //  If we break out here, then there is nothing to undo since we
170                //  haven't updated any pointers yet.
171                //
172                if (srcPtr + trailingBytes >= srcEnd)
173                        break;
174
175                // Looks ok, so lets build up the value
176                // or at least let's try to do so--remembering that
177                // we cannot assume the encoding to be valid:
178
179                // first, test first byte
180                if((gUTFByteIndicatorTest[trailingBytes] & *srcPtr) != gUTFByteIndicator[trailingBytes]) {
181                        char pos[2] = {(char)0x31, 0};
182                        char len[2] = {(char)(trailingBytes+0x31), 0};
183            char byte[2] = {(char)*srcPtr, 0};
184                        ThrowXMLwithMemMgr3(UTFDataFormatException, XMLExcepts::UTF8_FormatError, pos, byte, len, getMemoryManager());
185                }
186
187                /***
188                 * http://www.unicode.org/reports/tr27/
189                 *
190                 * Table 3.1B. lists all of the byte sequences that are legal in UTF-8.
191                 * A range of byte values such as A0..BF indicates that any byte from A0 to BF (inclusive)
192                 * is legal in that position.
193                 * Any byte value outside of the ranges listed is illegal.
194                 * For example,
195                 * the byte sequence <C0 AF> is illegal  since C0 is not legal in the 1st Byte column.
196                 * The byte sequence <E0 9F 80> is illegal since in the row
197                 *    where E0 is legal as a first byte,
198                 *    9F is not legal as a second byte.
199                 * The byte sequence <F4 80 83 92> is legal, since every byte in that sequence matches
200                 * a byte range in a row of the table (the last row).
201                 *
202                 *
203                 * Table 3.1B. Legal UTF-8 Byte Sequences
204                 * Code Points              1st Byte    2nd Byte    3rd Byte    4th Byte
205                 * =========================================================================
206                 * U+0000..U+007F            00..7F
207                 * -------------------------------------------------------------------------
208                 * U+0080..U+07FF            C2..DF      80..BF
209                 *
210                 * -------------------------------------------------------------------------
211                 * U+0800..U+0FFF            E0          A0..BF     80..BF
212                 *                                       --
213                 *
214                 * U+1000..U+FFFF            E1..EF      80..BF     80..BF
215                 *
216                 * --------------------------------------------------------------------------
217                 * U+10000..U+3FFFF          F0          90..BF     80..BF       80..BF
218                 *                                       --
219                 * U+40000..U+FFFFF          F1..F3      80..BF     80..BF       80..BF
220                 * U+100000..U+10FFFF        F4          80..8F     80..BF       80..BF
221                 *                                           --
222                 * ==========================================================================
223                 *
224                 *  Cases where a trailing byte range is not 80..BF are underlined in the table to
225                 *  draw attention to them. These occur only in the second byte of a sequence.
226                 *
227                 ***/
228
229                XMLUInt32 tmpVal = 0;
230
231        switch (trailingBytes)
232                {
233                        case 1 :
234                                // UTF-8:   [110y yyyy] [10xx xxxx]
235                                // Unicode: [0000 0yyy] [yyxx xxxx]
236                                //
237                                // 0xC0, 0xC1 has been filtered out
238                                checkTrailingBytes(*(srcPtr+1), 1, 1);
239
240                                tmpVal = *srcPtr++;
241                                tmpVal <<= 6;
242                                tmpVal += *srcPtr++;
243
244                                break;
245                        case 2 :
246                                // UTF-8:   [1110 zzzz] [10yy yyyy] [10xx xxxx]
247                                // Unicode: [zzzz yyyy] [yyxx xxxx]
248                                //
249                                if (( *srcPtr == 0xE0) && ( *(srcPtr+1) < 0xA0))
250                                {
251                    char byte0[2] = {(char)*srcPtr    ,0};
252                    char byte1[2] = {(char)*(srcPtr+1),0};
253
254                                        ThrowXMLwithMemMgr2(UTFDataFormatException
255                                                                          , XMLExcepts::UTF8_Invalid_3BytesSeq
256                                                                          , byte0
257                                                                          , byte1
258                                                                          , getMemoryManager());
259                                }
260
261                                checkTrailingBytes(*(srcPtr+1), 2, 1);
262                                checkTrailingBytes(*(srcPtr+2), 2, 2);
263
264                                //
265                                // D36 (a) UTF-8 is the Unicode Transformation Format that serializes
266                                //         a Unicode code point as a sequence of one to four bytes,
267                                //         as specified in Table 3.1, UTF-8 Bit Distribution.
268                                //     (b) An illegal UTF-8 code unit sequence is any byte sequence that
269                                //         does not match the patterns listed in Table 3.1B, Legal UTF-8
270                                //         Byte Sequences.
271                                //     (c) An irregular UTF-8 code unit sequence is a six-byte sequence
272                                //         where the first three bytes correspond to a high surrogate,
273                                //         and the next three bytes correspond to a low surrogate.
274                                //         As a consequence of C12, these irregular UTF-8 sequences shall
275                                //         not be generated by a conformant process.
276                                //
277                                //irregular three bytes sequence
278                                // that is zzzzyy matches leading surrogate tag 110110 or
279                                //                       trailing surrogate tag 110111
280                                // *srcPtr=1110 1101
281                                // *(srcPtr+1)=1010 yyyy or
282                                // *(srcPtr+1)=1011 yyyy
283                                //
284                                // 0xED 1110 1101
285                                // 0xA0 1010 0000
286
287                                if ((*srcPtr == 0xED) && (*(srcPtr+1) >= 0xA0))
288                                {
289                    char byte0[2] = {(char)*srcPtr,    0};
290                    char byte1[2] = {(char)*(srcPtr+1),0};
291
292                                         ThrowXMLwithMemMgr2(UTFDataFormatException
293                                                          , XMLExcepts::UTF8_Irregular_3BytesSeq
294                                                          , byte0
295                                                          , byte1
296                                                          , getMemoryManager());
297                                }
298
299                                tmpVal = *srcPtr++;
300                                tmpVal <<= 6;
301                                tmpVal += *srcPtr++;
302                                tmpVal <<= 6;
303                                tmpVal += *srcPtr++;
304
305                                break;
306                        case 3 :
307                                // UTF-8:   [1111 0uuu] [10uu zzzz] [10yy yyyy] [10xx xxxx]*
308                                // Unicode: [1101 10ww] [wwzz zzyy] (high surrogate)
309                                //          [1101 11yy] [yyxx xxxx] (low surrogate)
310                                //          * uuuuu = wwww + 1
311                                //
312                                if (((*srcPtr == 0xF0) && (*(srcPtr+1) < 0x90)) ||
313                                        ((*srcPtr == 0xF4) && (*(srcPtr+1) > 0x8F))  )
314                                {
315                    char byte0[2] = {(char)*srcPtr    ,0};
316                    char byte1[2] = {(char)*(srcPtr+1),0};
317
318                                        ThrowXMLwithMemMgr2(UTFDataFormatException
319                                                                          , XMLExcepts::UTF8_Invalid_4BytesSeq
320                                                                          , byte0
321                                                                          , byte1
322                                                                          , getMemoryManager());
323                                }
324
325                                checkTrailingBytes(*(srcPtr+1), 3, 1);
326                                checkTrailingBytes(*(srcPtr+2), 3, 2);
327                                checkTrailingBytes(*(srcPtr+3), 3, 3);
328
329                                tmpVal = *srcPtr++;
330                                tmpVal <<= 6;
331                                tmpVal += *srcPtr++;
332                                tmpVal <<= 6;
333                                tmpVal += *srcPtr++;
334                                tmpVal <<= 6;
335                                tmpVal += *srcPtr++;
336
337                                break;
338                        default: // trailingBytes > 3
339
340                                /***
341                                 * The definition of UTF-8 in Annex D of ISO/IEC 10646-1:2000 also allows
342                                 * for the use of five- and six-byte sequences to encode characters that
343                                 * are outside the range of the Unicode character set; those five- and
344                                 * six-byte sequences are illegal for the use of UTF-8 as a transformation
345                                 * of Unicode characters. ISO/IEC 10646 does not allow mapping of unpaired
346                                 * surrogates, nor U+FFFE and U+FFFF (but it does allow other noncharacters).
347                                 ***/
348                                char len[2]  = {(char)(trailingBytes+0x31), 0};
349                char byte[2] = {(char)*srcPtr,0};
350
351                                ThrowXMLwithMemMgr2(UTFDataFormatException
352                                                                  , XMLExcepts::UTF8_Exceeds_BytesLimit
353                                                                  , byte
354                                                                  , len
355                                                                  , getMemoryManager());
356
357                                break;
358                }
359
360
361                // since trailingBytes comes from an array, this logic is redundant
362                //  default :
363                //      ThrowXMLwithMemMgr(TranscodingException, XMLExcepts::Trans_BadSrcSeq);
364                //}
365                tmpVal -= gUTFOffsets[trailingBytes];
366
367                //
368                //  If it will fit into a single char, then put it in. Otherwise
369                //  encode it as a surrogate pair. If its not valid, use the
370                //  replacement char.
371                //
372        if (likely(tmpVal <= 0xFFFF))
373                {
374                        *sizePtr++ = trailingBytes + 1;
375                        *outPtr++ = XMLCh(tmpVal);
376                }
377        else if (tmpVal > 0x10FFFF)
378                {
379                        //
380                        //  If we've gotten more than 32 chars so far, then just break
381                        //  out for now and lets process those. When we come back in
382                        //  here again, we'll get no chars and throw an exception. This
383                        //  way, the error will have a line and col number closer to
384                        //  the real problem area.
385                        //
386                        if ((outPtr - toFill) > 32)
387                                break;
388
389                        ThrowXMLwithMemMgr(TranscodingException, XMLExcepts::Trans_BadSrcSeq, getMemoryManager());
390                }
391                 else
392                {
393                        //
394                        //  If we have enough room to store the leading and trailing
395                        //  chars, then lets do it. Else, pretend this one never
396                        //  happened, and leave it for the next time. Since we don't
397                        //  update the bytes read until the bottom of the loop, by
398                        //  breaking out here its like it never happened.
399                        //
400                        if (outPtr + 1 >= outEnd)
401                                break;
402
403                        // Store the leading surrogate char
404                        tmpVal -= 0x10000;
405                        *sizePtr++ = trailingBytes + 1;
406                        *outPtr++ = XMLCh((tmpVal >> 10) + 0xD800);
407
408                        //
409                        //  And then the trailing char. This one accounts for no
410                        //  bytes eaten from the source, so set the char size for this
411                        //  one to be zero.
412                        //
413                        *sizePtr++ = 0;
414                        *outPtr++ = XMLCh((tmpVal & 0x3FF) + 0xDC00);
415                }
416        }
417
418        // Update the bytes eaten
419        bytesEaten = srcPtr - srcData;
420
421        // Return the characters read
422        return outPtr - toFill;
423}
424
425XMLSize_t
426XMLUTF8Transcoder::transcodeFrom( const  XMLByte* const         srcData
427                                , const XMLSize_t               srcCount
428                                ,       XMLCh* const            toFill
429                                , const XMLSize_t               maxChars
430                                ,       XMLSize_t&              bytesEaten)
431{
432    // Watch for pathological scenario. Shouldn't happen, but...
433    if (!srcCount || !maxChars)
434        return 0;
435
436    //
437    //  Get pointers to our start and end points of the input and output
438    //  buffers.
439    //
440    const XMLByte*  srcPtr = srcData;
441    const XMLByte*  srcEnd = srcPtr + srcCount;
442    XMLCh*          outPtr = toFill;
443    XMLCh*          outEnd = outPtr + maxChars;
444
445    //
446    //  We now loop until we either run out of input data, or room to store
447    //  output chars.
448    //
449    while ((srcPtr < srcEnd) && (outPtr < outEnd))
450    {
451        // Special-case ASCII, which is a leading byte value of <= 127
452        if (*srcPtr <= 127)
453        {
454            // Handle ASCII in groups instead of single character at a time.
455            const XMLSize_t chunkSize = (srcEnd-srcPtr)<(outEnd-outPtr)?(srcEnd-srcPtr):(outEnd-outPtr);
456            for(XMLSize_t i=0;i<chunkSize && *srcPtr <= 127;++i)
457                *outPtr++ = XMLCh(*srcPtr++);
458            if (srcPtr == srcEnd || outPtr == outEnd)
459                break;
460        }
461
462        // See how many trailing src bytes this sequence is going to require
463        const unsigned int trailingBytes = gUTFBytes[*srcPtr];
464
465        //
466        //  If there are not enough source bytes to do this one, then we
467        //  are done. Note that we done >= here because we are implicitly
468        //  counting the 1 byte we get no matter what.
469        //
470        //  If we break out here, then there is nothing to undo since we
471        //  haven't updated any pointers yet.
472        //
473        if (srcPtr + trailingBytes >= srcEnd)
474            break;
475
476        // Looks ok, so lets build up the value
477        // or at least let's try to do so--remembering that
478        // we cannot assume the encoding to be valid:
479
480        // first, test first byte
481        if((gUTFByteIndicatorTest[trailingBytes] & *srcPtr) != gUTFByteIndicator[trailingBytes]) {
482            char pos[2] = {(char)0x31, 0};
483            char len[2] = {(char)(trailingBytes+0x31), 0};
484            char byte[2] = {(char)*srcPtr, 0};
485            ThrowXMLwithMemMgr3(UTFDataFormatException, XMLExcepts::UTF8_FormatError, pos, byte, len, getMemoryManager());
486        }
487
488        /***
489         * http://www.unicode.org/reports/tr27/
490         *
491         * Table 3.1B. lists all of the byte sequences that are legal in UTF-8.
492         * A range of byte values such as A0..BF indicates that any byte from A0 to BF (inclusive)
493         * is legal in that position.
494         * Any byte value outside of the ranges listed is illegal.
495         * For example,
496         * the byte sequence <C0 AF> is illegal  since C0 is not legal in the 1st Byte column.
497         * The byte sequence <E0 9F 80> is illegal since in the row
498         *    where E0 is legal as a first byte,
499         *    9F is not legal as a second byte.
500         * The byte sequence <F4 80 83 92> is legal, since every byte in that sequence matches
501         * a byte range in a row of the table (the last row).
502         *
503         *
504         * Table 3.1B. Legal UTF-8 Byte Sequences
505         * Code Points              1st Byte    2nd Byte    3rd Byte    4th Byte
506         * =========================================================================
507         * U+0000..U+007F            00..7F
508         * -------------------------------------------------------------------------
509         * U+0080..U+07FF            C2..DF      80..BF
510         *
511         * -------------------------------------------------------------------------
512         * U+0800..U+0FFF            E0          A0..BF     80..BF
513         *                                       --
514         *
515         * U+1000..U+FFFF            E1..EF      80..BF     80..BF
516         *
517         * --------------------------------------------------------------------------
518         * U+10000..U+3FFFF          F0          90..BF     80..BF       80..BF
519         *                                       --
520         * U+40000..U+FFFFF          F1..F3      80..BF     80..BF       80..BF
521         * U+100000..U+10FFFF        F4          80..8F     80..BF       80..BF
522         *                                           --
523         * ==========================================================================
524         *
525         *  Cases where a trailing byte range is not 80..BF are underlined in the table to
526         *  draw attention to them. These occur only in the second byte of a sequence.
527         *
528         ***/
529
530        XMLUInt32 tmpVal = 0;
531
532        switch (trailingBytes)
533        {
534            case 1 :
535                // UTF-8:   [110y yyyy] [10xx xxxx]
536                // Unicode: [0000 0yyy] [yyxx xxxx]
537                //
538                // 0xC0, 0xC1 has been filtered out
539                checkTrailingBytes(*(srcPtr+1), 1, 1);
540
541                tmpVal = *srcPtr++;
542                tmpVal <<= 6;
543                tmpVal += *srcPtr++;
544
545                break;
546            case 2 :
547                // UTF-8:   [1110 zzzz] [10yy yyyy] [10xx xxxx]
548                // Unicode: [zzzz yyyy] [yyxx xxxx]
549                //
550                if (( *srcPtr == 0xE0) && ( *(srcPtr+1) < 0xA0))
551                {
552                    char byte0[2] = {(char)*srcPtr    ,0};
553                    char byte1[2] = {(char)*(srcPtr+1),0};
554
555                    ThrowXMLwithMemMgr2(UTFDataFormatException
556                                      , XMLExcepts::UTF8_Invalid_3BytesSeq
557                                      , byte0
558                                      , byte1
559                                      , getMemoryManager());
560                }
561
562                checkTrailingBytes(*(srcPtr+1), 2, 1);
563                checkTrailingBytes(*(srcPtr+2), 2, 2);
564
565                //
566                // D36 (a) UTF-8 is the Unicode Transformation Format that serializes
567                //         a Unicode code point as a sequence of one to four bytes,
568                //         as specified in Table 3.1, UTF-8 Bit Distribution.
569                //     (b) An illegal UTF-8 code unit sequence is any byte sequence that
570                //         does not match the patterns listed in Table 3.1B, Legal UTF-8
571                //         Byte Sequences.
572                //     (c) An irregular UTF-8 code unit sequence is a six-byte sequence
573                //         where the first three bytes correspond to a high surrogate,
574                //         and the next three bytes correspond to a low surrogate.
575                //         As a consequence of C12, these irregular UTF-8 sequences shall
576                //         not be generated by a conformant process.
577                //
578                //irregular three bytes sequence
579                // that is zzzzyy matches leading surrogate tag 110110 or
580                //                       trailing surrogate tag 110111
581                // *srcPtr=1110 1101
582                // *(srcPtr+1)=1010 yyyy or
583                // *(srcPtr+1)=1011 yyyy
584                //
585                // 0xED 1110 1101
586                // 0xA0 1010 0000
587
588                if ((*srcPtr == 0xED) && (*(srcPtr+1) >= 0xA0))
589                {
590                    char byte0[2] = {(char)*srcPtr,    0};
591                    char byte1[2] = {(char)*(srcPtr+1),0};
592
593                     ThrowXMLwithMemMgr2(UTFDataFormatException
594                              , XMLExcepts::UTF8_Irregular_3BytesSeq
595                              , byte0
596                              , byte1
597                              , getMemoryManager());
598                }
599
600                tmpVal = *srcPtr++;
601                tmpVal <<= 6;
602                tmpVal += *srcPtr++;
603                tmpVal <<= 6;
604                tmpVal += *srcPtr++;
605
606                break;
607            case 3 :
608                // UTF-8:   [1111 0uuu] [10uu zzzz] [10yy yyyy] [10xx xxxx]*
609                // Unicode: [1101 10ww] [wwzz zzyy] (high surrogate)
610                //          [1101 11yy] [yyxx xxxx] (low surrogate)
611                //          * uuuuu = wwww + 1
612                //
613                if (((*srcPtr == 0xF0) && (*(srcPtr+1) < 0x90)) ||
614                    ((*srcPtr == 0xF4) && (*(srcPtr+1) > 0x8F))  )
615                {
616                    char byte0[2] = {(char)*srcPtr    ,0};
617                    char byte1[2] = {(char)*(srcPtr+1),0};
618
619                    ThrowXMLwithMemMgr2(UTFDataFormatException
620                                      , XMLExcepts::UTF8_Invalid_4BytesSeq
621                                      , byte0
622                                      , byte1
623                                      , getMemoryManager());
624                }
625
626                checkTrailingBytes(*(srcPtr+1), 3, 1);
627                checkTrailingBytes(*(srcPtr+2), 3, 2);
628                checkTrailingBytes(*(srcPtr+3), 3, 3);
629
630                tmpVal = *srcPtr++;
631                tmpVal <<= 6;
632                tmpVal += *srcPtr++;
633                tmpVal <<= 6;
634                tmpVal += *srcPtr++;
635                tmpVal <<= 6;
636                tmpVal += *srcPtr++;
637
638                break;
639            default: // trailingBytes > 3
640
641                /***
642                 * The definition of UTF-8 in Annex D of ISO/IEC 10646-1:2000 also allows
643                 * for the use of five- and six-byte sequences to encode characters that
644                 * are outside the range of the Unicode character set; those five- and
645                 * six-byte sequences are illegal for the use of UTF-8 as a transformation
646                 * of Unicode characters. ISO/IEC 10646 does not allow mapping of unpaired
647                 * surrogates, nor U+FFFE and U+FFFF (but it does allow other noncharacters).
648                 ***/
649                char len[2]  = {(char)(trailingBytes+0x31), 0};
650                char byte[2] = {(char)*srcPtr,0};
651
652                ThrowXMLwithMemMgr2(UTFDataFormatException
653                                  , XMLExcepts::UTF8_Exceeds_BytesLimit
654                                  , byte
655                                  , len
656                                  , getMemoryManager());
657
658                break;
659        }
660
661
662        // since trailingBytes comes from an array, this logic is redundant
663        //  default :
664        //      ThrowXMLwithMemMgr(TranscodingException, XMLExcepts::Trans_BadSrcSeq);
665        //}
666        tmpVal -= gUTFOffsets[trailingBytes];
667
668        //
669        //  If it will fit into a single char, then put it in. Otherwise
670        //  encode it as a surrogate pair. If its not valid, use the
671        //  replacement char.
672        //
673        if (tmpVal <= 0xFFFF)
674        {
675            *outPtr++ = XMLCh(tmpVal);
676        }
677        else if (tmpVal > 0x10FFFF)
678        {
679            //
680            //  If we've gotten more than 32 chars so far, then just break
681            //  out for now and lets process those. When we come back in
682            //  here again, we'll get no chars and throw an exception. This
683            //  way, the error will have a line and col number closer to
684            //  the real problem area.
685            //
686            if ((outPtr - toFill) > 32)
687                break;
688
689            ThrowXMLwithMemMgr(TranscodingException, XMLExcepts::Trans_BadSrcSeq, getMemoryManager());
690        }
691         else
692        {
693            //
694            //  If we have enough room to store the leading and trailing
695            //  chars, then lets do it. Else, pretend this one never
696            //  happened, and leave it for the next time. Since we don't
697            //  update the bytes read until the bottom of the loop, by
698            //  breaking out here its like it never happened.
699            //
700            if (outPtr + 1 >= outEnd)
701                break;
702
703            // Store the leading surrogate char
704            tmpVal -= 0x10000;
705            *outPtr++ = XMLCh((tmpVal >> 10) + 0xD800);
706
707            //
708            //  And then the trailing char. This one accounts for no
709            //  bytes eaten from the source, so set the char size for this
710            //  one to be zero.
711            //
712            *outPtr++ = XMLCh((tmpVal & 0x3FF) + 0xDC00);
713        }
714    }
715
716    // Update the bytes eaten
717    bytesEaten = srcPtr - srcData;
718
719    // Return the characters read
720    return outPtr - toFill;
721}
722
723
724XMLSize_t
725XMLUTF8Transcoder::transcodeFrom( const XMLByte* const          srcData
726                                                                , const XMLSize_t               srcCount
727                                                                ,       XMLBuffer &             toFill )
728{
729        // Watch for pathological scenario. Shouldn't happen, but...
730        if (!srcCount)
731                return 0;
732
733    toFill.ensureCapacity(srcCount);
734
735        //
736        //  Get pointers to our start and end points of the input and output
737        //  buffers.
738        //
739        const XMLByte * srcPtr = srcData;
740        const XMLByte * const srcEnd = srcPtr + srcCount;
741
742        //
743        //  We now loop until we either run out of input data, or room to store
744        //  output chars.
745        //
746        while (srcPtr < srcEnd)
747        {
748                // Special-case ASCII, which is a leading byte value of <= 127
749                if (unlikely(*srcPtr <= 127))
750                {
751                        toFill.append(XMLCh(*srcPtr++));
752                        XMLSize_t count = (srcEnd - srcPtr);
753                        // Handle ASCII in groups instead of single character at a time.
754                        for(; count && *srcPtr <= 127; --count)
755                                toFill.append(XMLCh(*srcPtr++));
756
757                        if (!count) break;
758                }
759
760                // See how many trailing src bytes this sequence is going to require
761                const unsigned int trailingBytes = gUTFBytes[*srcPtr];
762
763                //
764                //  If there are not enough source bytes to do this one, then we
765                //  are done. Note that we done >= here because we are implicitly
766                //  counting the 1 byte we get no matter what.
767                //
768                //  If we break out here, then there is nothing to undo since we
769                //  haven't updated any pointers yet.
770                //
771                if (srcPtr + trailingBytes >= srcEnd)
772                        break;
773
774                // Looks ok, so lets build up the value
775                // or at least let's try to do so--remembering that
776                // we cannot assume the encoding to be valid:
777
778                // first, test first byte
779                if((gUTFByteIndicatorTest[trailingBytes] & *srcPtr) != gUTFByteIndicator[trailingBytes]) {
780                        char pos[2] = {(char)0x31, 0};
781                        char len[2] = {(char)(trailingBytes+0x31), 0};
782            char byte[2] = {(char)*srcPtr,0};
783                        ThrowXMLwithMemMgr3(UTFDataFormatException, XMLExcepts::UTF8_FormatError, pos, byte, len, getMemoryManager());
784                }
785
786                /***
787                 * http://www.unicode.org/reports/tr27/
788                 *
789                 * Table 3.1B. lists all of the byte sequences that are legal in UTF-8.
790                 * A range of byte values such as A0..BF indicates that any byte from A0 to BF (inclusive)
791                 * is legal in that position.
792                 * Any byte value outside of the ranges listed is illegal.
793                 * For example,
794                 * the byte sequence <C0 AF> is illegal  since C0 is not legal in the 1st Byte column.
795                 * The byte sequence <E0 9F 80> is illegal since in the row
796                 *    where E0 is legal as a first byte,
797                 *    9F is not legal as a second byte.
798                 * The byte sequence <F4 80 83 92> is legal, since every byte in that sequence matches
799                 * a byte range in a row of the table (the last row).
800                 *
801                 *
802                 * Table 3.1B. Legal UTF-8 Byte Sequences
803                 * Code Points              1st Byte    2nd Byte    3rd Byte    4th Byte
804                 * =========================================================================
805                 * U+0000..U+007F            00..7F
806                 * -------------------------------------------------------------------------
807                 * U+0080..U+07FF            C2..DF      80..BF
808                 *
809                 * -------------------------------------------------------------------------
810                 * U+0800..U+0FFF            E0          A0..BF     80..BF
811                 *                                       --
812                 *
813                 * U+1000..U+FFFF            E1..EF      80..BF     80..BF
814                 *
815                 * --------------------------------------------------------------------------
816                 * U+10000..U+3FFFF          F0          90..BF     80..BF       80..BF
817                 *                                       --
818                 * U+40000..U+FFFFF          F1..F3      80..BF     80..BF       80..BF
819                 * U+100000..U+10FFFF        F4          80..8F     80..BF       80..BF
820                 *                                           --
821                 * ==========================================================================
822                 *
823                 *  Cases where a trailing byte range is not 80..BF are underlined in the table to
824                 *  draw attention to them. These occur only in the second byte of a sequence.
825                 *
826                 ***/
827
828                XMLUInt32 tmpVal = 0;
829
830                switch (trailingBytes)
831                {
832                        case 1 :
833                                // UTF-8:   [110y yyyy] [10xx xxxx]
834                                // Unicode: [0000 0yyy] [yyxx xxxx]
835                                //
836                                // 0xC0, 0xC1 has been filtered out
837                                checkTrailingBytes(*(srcPtr+1), 1, 1);
838
839                                tmpVal = *srcPtr++;
840                                tmpVal <<= 6;
841                                tmpVal += *srcPtr++;
842
843                                break;
844                        case 2 :
845                                // UTF-8:   [1110 zzzz] [10yy yyyy] [10xx xxxx]
846                                // Unicode: [zzzz yyyy] [yyxx xxxx]
847                                //
848                                if (( *srcPtr == 0xE0) && ( *(srcPtr+1) < 0xA0))
849                                {
850                    char byte0[2] = {(char)*srcPtr    ,0};
851                    char byte1[2] = {(char)*(srcPtr+1),0};
852
853                                        ThrowXMLwithMemMgr2(UTFDataFormatException
854                                                                          , XMLExcepts::UTF8_Invalid_3BytesSeq
855                                                                          , byte0
856                                                                          , byte1
857                                                                          , getMemoryManager());
858                                }
859
860                                checkTrailingBytes(*(srcPtr+1), 2, 1);
861                                checkTrailingBytes(*(srcPtr+2), 2, 2);
862
863                                //
864                                // D36 (a) UTF-8 is the Unicode Transformation Format that serializes
865                                //         a Unicode code point as a sequence of one to four bytes,
866                                //         as specified in Table 3.1, UTF-8 Bit Distribution.
867                                //     (b) An illegal UTF-8 code unit sequence is any byte sequence that
868                                //         does not match the patterns listed in Table 3.1B, Legal UTF-8
869                                //         Byte Sequences.
870                                //     (c) An irregular UTF-8 code unit sequence is a six-byte sequence
871                                //         where the first three bytes correspond to a high surrogate,
872                                //         and the next three bytes correspond to a low surrogate.
873                                //         As a consequence of C12, these irregular UTF-8 sequences shall
874                                //         not be generated by a conformant process.
875                                //
876                                //irregular three bytes sequence
877                                // that is zzzzyy matches leading surrogate tag 110110 or
878                                //                       trailing surrogate tag 110111
879                                // *srcPtr=1110 1101
880                                // *(srcPtr+1)=1010 yyyy or
881                                // *(srcPtr+1)=1011 yyyy
882                                //
883                                // 0xED 1110 1101
884                                // 0xA0 1010 0000
885
886                                if ((*srcPtr == 0xED) && (*(srcPtr+1) >= 0xA0))
887                                {
888                    char byte0[2] = {(char)*srcPtr,    0};
889                    char byte1[2] = {(char)*(srcPtr+1),0};
890
891                                         ThrowXMLwithMemMgr2(UTFDataFormatException
892                                                          , XMLExcepts::UTF8_Irregular_3BytesSeq
893                                                          , byte0
894                                                          , byte1
895                                                          , getMemoryManager());
896                                }
897
898                                tmpVal = *srcPtr++;
899                                tmpVal <<= 6;
900                                tmpVal += *srcPtr++;
901                                tmpVal <<= 6;
902                                tmpVal += *srcPtr++;
903
904                                break;
905                        case 3 :
906                                // UTF-8:   [1111 0uuu] [10uu zzzz] [10yy yyyy] [10xx xxxx]*
907                                // Unicode: [1101 10ww] [wwzz zzyy] (high surrogate)
908                                //          [1101 11yy] [yyxx xxxx] (low surrogate)
909                                //          * uuuuu = wwww + 1
910                                //
911                                if (((*srcPtr == 0xF0) && (*(srcPtr+1) < 0x90)) ||
912                                        ((*srcPtr == 0xF4) && (*(srcPtr+1) > 0x8F))  )
913                                {
914                    char byte0[2] = {(char)*srcPtr    ,0};
915                    char byte1[2] = {(char)*(srcPtr+1),0};
916
917                                        ThrowXMLwithMemMgr2(UTFDataFormatException
918                                                                          , XMLExcepts::UTF8_Invalid_4BytesSeq
919                                                                          , byte0
920                                                                          , byte1
921                                                                          , getMemoryManager());
922                                }
923
924                                checkTrailingBytes(*(srcPtr+1), 3, 1);
925                                checkTrailingBytes(*(srcPtr+2), 3, 2);
926                                checkTrailingBytes(*(srcPtr+3), 3, 3);
927
928                                tmpVal = *srcPtr++;
929                                tmpVal <<= 6;
930                                tmpVal += *srcPtr++;
931                                tmpVal <<= 6;
932                                tmpVal += *srcPtr++;
933                                tmpVal <<= 6;
934                                tmpVal += *srcPtr++;
935
936                                break;
937                        default: // trailingBytes > 3
938
939                                /***
940                                 * The definition of UTF-8 in Annex D of ISO/IEC 10646-1:2000 also allows
941                                 * for the use of five- and six-byte sequences to encode characters that
942                                 * are outside the range of the Unicode character set; those five- and
943                                 * six-byte sequences are illegal for the use of UTF-8 as a transformation
944                                 * of Unicode characters. ISO/IEC 10646 does not allow mapping of unpaired
945                                 * surrogates, nor U+FFFE and U+FFFF (but it does allow other noncharacters).
946                                 ***/
947                                char len[2]  = {(char)(trailingBytes+0x31), 0};
948                char byte[2] = {(char)*srcPtr,0};
949
950                                ThrowXMLwithMemMgr2(UTFDataFormatException
951                                                                  , XMLExcepts::UTF8_Exceeds_BytesLimit
952                                                                  , byte
953                                                                  , len
954                                                                  , getMemoryManager());
955
956                                break;
957                }
958
959
960                // since trailingBytes comes from an array, this logic is redundant
961                //  default :
962                //      ThrowXMLwithMemMgr(TranscodingException, XMLExcepts::Trans_BadSrcSeq);
963                //}
964                tmpVal -= gUTFOffsets[trailingBytes];
965
966                //
967                //  If it will fit into a single char, then put it in. Otherwise
968                //  encode it as a surrogate pair. If its not valid, use the
969                //  replacement char.
970                //
971                if (!(tmpVal & 0xFFFF0000))
972                {
973                        toFill.append(XMLCh(tmpVal));
974                }
975                else if (tmpVal > 0x10FFFF)
976                {
977                        //
978                        //  If we've gotten more than 32 chars so far, then just break
979                        //  out for now and lets process those. When we come back in
980                        //  here again, we'll get no chars and throw an exception. This
981                        //  way, the error will have a line and col number closer to
982                        //  the real problem area.
983                        //
984
985                        ThrowXMLwithMemMgr(TranscodingException, XMLExcepts::Trans_BadSrcSeq, getMemoryManager());
986                }
987                 else
988                {
989                        //
990                        //  If we have enough room to store the leading and trailing
991                        //  chars, then lets do it. Else, pretend this one never
992                        //  happened, and leave it for the next time. Since we don't
993                        //  update the bytes read until the bottom of the loop, by
994                        //  breaking out here its like it never happened.
995                        //
996
997                        // Store the leading surrogate char
998                        tmpVal -= 0x10000;
999                        toFill.append(XMLCh((tmpVal >> 10) + 0xD800));
1000
1001                        //
1002                        //  And then the trailing char. This one accounts for no
1003                        //  bytes eaten from the source, so set the char size for this
1004                        //  one to be zero.
1005                        //
1006                        toFill.append(XMLCh((tmpVal & 0x3FF) + 0xDC00));
1007                }
1008        }
1009
1010        // Return the bytes eaten
1011        return srcPtr - srcData;
1012}
1013
1014
1015XMLSize_t
1016XMLUTF8Transcoder::transcodeTo( const   XMLCh*  const srcData
1017                                                          , const XMLSize_t       srcCount
1018                                                          ,       XMLByte*  const toFill
1019                                                          , const XMLSize_t       maxBytes
1020                                                          ,       XMLSize_t&      charsEaten
1021                                                          , const UnRepOpts       options)
1022{
1023        // Watch for pathological scenario. Shouldn't happen, but...
1024        if (!srcCount || !maxBytes)
1025                return 0;
1026
1027        //
1028        //  Get pointers to our start and end points of the input and output
1029        //  buffers.
1030        //
1031        const XMLCh*    srcPtr = srcData;
1032        const XMLCh*    srcEnd = srcPtr + srcCount;
1033        XMLByte*        outPtr = toFill;
1034        XMLByte*        outEnd = toFill + maxBytes;
1035
1036        while (srcPtr < srcEnd)
1037        {
1038                //
1039                //  Tentatively get the next char out. We have to get it into a
1040                //  32 bit value, because it could be a surrogate pair.
1041                //
1042                XMLUInt32 curVal = *srcPtr;
1043
1044                //
1045                //  If its a leading surrogate, then lets see if we have the trailing
1046                //  available. If not, then give up now and leave it for next time.
1047                //
1048                unsigned int srcUsed = 1;
1049                if ((curVal >= 0xD800) && (curVal <= 0xDBFF))
1050                {
1051                        if (srcPtr + 1 >= srcEnd)
1052                                break;
1053
1054                        // Create the composite surrogate pair
1055                        curVal = ((curVal - 0xD800) << 10)
1056                                        + ((*(srcPtr + 1) - 0xDC00) + 0x10000);
1057
1058                        // And indicate that we ate another one
1059                        srcUsed++;
1060                }
1061
1062                // Figure out how many bytes we need
1063                unsigned int encodedBytes;
1064                if (curVal < 0x80)
1065                        encodedBytes = 1;
1066                else if (curVal < 0x800)
1067                        encodedBytes = 2;
1068                else if (curVal < 0x10000)
1069                        encodedBytes = 3;
1070                else if (curVal < 0x110000)
1071                        encodedBytes = 4;
1072                else
1073                {
1074                        // If the options say to throw, then throw
1075                        if (options == UnRep_Throw)
1076                        {
1077                                XMLCh tmpBuf[17];
1078                                XMLString::binToText(curVal, tmpBuf, 16, 16, getMemoryManager());
1079                                ThrowXMLwithMemMgr2
1080                                (
1081                                        TranscodingException
1082                                        , XMLExcepts::Trans_Unrepresentable
1083                                        , tmpBuf
1084                                        , getEncodingName()
1085                                        , getMemoryManager()
1086                                );
1087                        }
1088
1089                        // Else, use the replacement character
1090                        *outPtr++ = chSpace;
1091                        srcPtr += srcUsed;
1092                        continue;
1093                }
1094
1095                //
1096                //  If we cannot fully get this char into the output buffer,
1097                //  then leave it for the next time.
1098                //
1099                if (outPtr + encodedBytes > outEnd)
1100                        break;
1101
1102                // We can do it, so update the source index
1103                srcPtr += srcUsed;
1104
1105                //
1106                //  And spit out the bytes. We spit them out in reverse order
1107                //  here, so bump up the output pointer and work down as we go.
1108                //
1109                outPtr += encodedBytes;
1110                switch(encodedBytes)
1111                {
1112                        case 6 : *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL);
1113                                         curVal >>= 6;
1114                        case 5 : *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL);
1115                                         curVal >>= 6;
1116                        case 4 : *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL);
1117                                         curVal >>= 6;
1118                        case 3 : *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL);
1119                                         curVal >>= 6;
1120                        case 2 : *--outPtr = XMLByte((curVal | 0x80UL) & 0xBFUL);
1121                                         curVal >>= 6;
1122                        case 1 : *--outPtr = XMLByte
1123                                         (
1124                                                curVal | gFirstByteMark[encodedBytes]
1125                                         );
1126                }
1127
1128                // Add the encoded bytes back in again to indicate we've eaten them
1129                outPtr += encodedBytes;
1130        }
1131
1132        // Fill in the chars we ate
1133        charsEaten = (srcPtr - srcData);
1134
1135        // And return the bytes we filled in
1136        return (outPtr - toFill);
1137}
1138
1139
1140bool XMLUTF8Transcoder::canTranscodeTo(const unsigned int toCheck)
1141{
1142        // We can represent anything in the Unicode (with surrogates) range
1143        return (toCheck <= 0x10FFFF);
1144}
1145
1146
1147XERCES_CPP_NAMESPACE_END
Note: See TracBrowser for help on using the repository browser.