source: icXML/icXML-devel/src/icxmlc/XMLUTF16CharacterSetAdapter.cpp @ 2720

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

Initial check-in of icXML 0.8 source files

File size: 37.6 KB
Line 
1/*
2 *  Copyright © 2012 International Characters.
3 *  This software is licensed to the public under the Open Software License 3.0.
4 *  icXML is a trademark of International Characters.
5 */
6
7/*
8 * @author Nigel Medforth, nigelm -at- interational-characters.com
9 * @version $Id: XMLUTF16CharacterSetAdapter.cpp 217 2012-12-03 15:00:50Z robc $
10 *
11 */
12
13
14// ---------------------------------------------------------------------------
15//  Includes
16// ---------------------------------------------------------------------------
17#include <xercesc/util/BitOps.hpp>
18#include <xercesc/util/XMLUTF16Transcoder.hpp>
19#include <icxmlc/XMLUTF16CharacterSetAdapter.hpp>
20#include <xercesc/util/TranscodingException.hpp>
21#include <string.h>
22
23#include <xercesc/util/XMLUniDefs.hpp>
24#include <xercesc/internal/XMLReader.hpp>
25#include <xercesc/internal/XMLScanner.hpp>
26#include <xercesc/util/XMLString.hpp>
27
28#include <simd-lib/s2p.hpp>
29#include <simd-lib/p2s.hpp>
30#include <simd-lib/carryQ.hpp>
31#include <simd-lib/bitblock_iterator.hpp>
32
33#include <icxmlc/XMLMultiliteral.h>
34#include <icxmlc/PopCounter.hpp>
35#include <icxmlc/BitTracker.hpp>
36#include <icxmlc/XMLScanIterator.hpp>
37#include <icxmlc/XMLStreamIterator.hpp>
38#include <icxmlc/XMLLineColTracker.hpp>
39#include <icxmlc/XMLReferenceTable.hpp>
40#include <icxmlc/XMLConfig.hpp>
41
42XERCES_CPP_NAMESPACE_BEGIN
43
44
45// --------------------------------------------------------------------------------------
46// XMLUTF16CharacterSetAdapter
47// --------------------------------------------------------------------------------------
48
49#define do_right8_shifts(vec, rshift1, rshift2, rshift4) \
50do { \
51        BitBlock s2; \
52        vec = simd<8>::sub(vec, simd<16>::srli<1>(simd_and(rshift1, vec))); \
53        s2 = simd_and(rshift2, vec);\
54        vec = simd_or(simd<16>::srli<2>(s2), simd_xor(vec, s2));\
55        s2 = simd_and(rshift4, vec);\
56        vec = simd_or(simd<16>::srli<4>(s2), simd_xor(vec, s2));\
57} while(0)
58
59#define del_info_8(delmask, rshift1, rshift2, rshift4) \
60do { \
61        BitBlock del8_trans2; \
62        BitBlock del8_trans4; \
63        BitBlock shift_bits; \
64        rshift1 = simd_xor(simd<8>::slli<1>(delmask), simd<8>::slli<2>(delmask)); \
65        rshift1 = simd_xor(rshift1, simd<8>::slli<2>(rshift1)); \
66        rshift1 = simd_xor(rshift1, simd<8>::slli<4>(rshift1)); \
67        /* Transition to even delcount: odd delcount to left, this one deleted. */ \
68        del8_trans2 = simd_and(rshift1, delmask); \
69        /* Odd number of transition positions to left. */ \
70        rshift2 = simd_xor(simd<8>::slli<1>(del8_trans2), simd<8>::slli<2>(del8_trans2)); \
71        rshift2 = simd_xor(rshift2, simd<8>::slli<2>(rshift2)); \
72        rshift2 = simd_xor(rshift2, simd<8>::slli<4>(rshift2)); \
73        /* Transition positions: odd |del2count| to left, this one a transition to even. */ \
74        del8_trans4 = simd_and(rshift2, del8_trans2); \
75        rshift4 = simd_xor(simd<8>::slli<1>(del8_trans4), simd<8>::slli<2>(del8_trans4)); \
76        rshift4 = simd_xor(rshift4, simd<8>::slli<2>(rshift4)); \
77        rshift4 = simd_xor(rshift4, simd<8>::slli<4>(rshift4)); \
78        /* Only move bits that are not deleted. */ \
79        rshift1 = simd_andc(rshift1, delmask); \
80        rshift2 = simd_andc(rshift2, delmask); \
81        rshift4 = simd_andc(rshift4, delmask); \
82        /* Update |del8_rshift2| to apply after |del8_rshift1|. */ \
83        rshift2 = simd<8>::sub(rshift2, simd<16>::srli<1>(simd_and(rshift1, rshift2))); \
84        /* Update |del8_rshift4| to apply after |del8_rshift2| and |del8_rshift1|. */ \
85        rshift4 = simd<8>::sub(rshift4, simd<16>::srli<1>(simd_and(rshift1, rshift4))); \
86        shift_bits = simd_and(rshift2, rshift4); \
87        rshift4 = simd_or(simd<16>::srli<2>(shift_bits), simd_xor(rshift4, shift_bits)); \
88} while(0)
89
90static inline void del_count(BitBlock delmask, BitBlock & u16_units_per_reg)
91{
92        BitBlock delcounts_8 = simd<8>::popcount(delmask);
93        u16_units_per_reg = simd<8>::sub(simd<8>::constant<8>(), delcounts_8);
94}
95
96IDISA_ALWAYS_INLINE
97XMLCh * XMLUTF16CharacterSetAdapter::buildOutputStream
98(
99        const Marker    &                               marker
100        , const Callouts  &                             callouts
101        ,       U16hi     &                             u16hi
102        ,       U16lo     &                             u16lo
103        , const XMLByte   *                             source
104        , const size_t                                  offset
105        ,               ContentStream &                 contentStream
106        ,       XMLCh *                                 contentStreamPtr
107        ,               StringPtrArray &                stringEndArray
108        , const XMLCh     ** &                  stringEndPtr
109        ,       unsigned int &                  refMarkupCount
110        ,       unsigned int &                  refSymbolCount
111        ,               XMLComplexRefArray &    complexRefArray
112        ,               XMLSize_t &                             complexRefCount
113)
114{
115        BitBlock shift1, shift2, shift4;
116        del_info_8(callouts.delmask, shift1, shift2, shift4);
117        ubitblock del;
118        del_count(callouts.delmask, del._128);
119
120        BytePack U16h[8];
121        BytePack U16l[8];
122
123        do_right8_shifts(u16lo.bit_0, shift1, shift2, shift4);
124        do_right8_shifts(u16lo.bit_1, shift1, shift2, shift4);
125        do_right8_shifts(u16lo.bit_2, shift1, shift2, shift4);
126        do_right8_shifts(u16lo.bit_3, shift1, shift2, shift4);
127        do_right8_shifts(u16lo.bit_4, shift1, shift2, shift4);
128        do_right8_shifts(u16lo.bit_5, shift1, shift2, shift4);
129        do_right8_shifts(u16lo.bit_6, shift1, shift2, shift4);
130        do_right8_shifts(u16lo.bit_7, shift1, shift2, shift4);
131        do_right8_shifts(u16hi.bit_0, shift1, shift2, shift4);
132        do_right8_shifts(u16hi.bit_1, shift1, shift2, shift4);
133        do_right8_shifts(u16hi.bit_2, shift1, shift2, shift4);
134        do_right8_shifts(u16hi.bit_3, shift1, shift2, shift4);
135        do_right8_shifts(u16hi.bit_4, shift1, shift2, shift4);
136        do_right8_shifts(u16hi.bit_5, shift1, shift2, shift4);
137        do_right8_shifts(u16hi.bit_6, shift1, shift2, shift4);
138        do_right8_shifts(u16hi.bit_7, shift1, shift2, shift4);
139
140        p2s(u16lo.bit_0,u16lo.bit_1,u16lo.bit_2,u16lo.bit_3,u16lo.bit_4,u16lo.bit_5,u16lo.bit_6,u16lo.bit_7,
141                U16l[0], U16l[1],U16l[2] ,U16l[3] ,U16l[4] ,U16l[5] ,U16l[6] ,U16l[7]);
142
143        p2s(u16hi.bit_0,u16hi.bit_1,u16hi.bit_2,u16hi.bit_3,u16hi.bit_4,u16hi.bit_5,u16hi.bit_6,u16hi.bit_7,
144                U16h[0], U16h[1],U16h[2] ,U16h[3] ,U16h[4] ,U16h[5] ,U16h[6] ,U16h[7]);
145
146        /* --------------------------------------------------------------------- */
147        /* WRITE THE CONTENT STREAM
148        /* --------------------------------------------------------------------- */
149
150        XMLCh * contentStreamPtr0 = contentStreamPtr;
151
152    for (unsigned int i = 0; i < 8; i++)
153    {
154        ubitblock bl;
155        ubitblock bh;
156
157        #ifdef USE_UTF16_BIG_ENDIAN
158        bl._128 = esimd<8>::mergel(U16l[i], U16h[i]);
159        bh._128 = esimd<8>::mergeh(U16l[i], U16h[i]);
160        #else
161        bl._128 = esimd<8>::mergel(U16h[i], U16l[i]);
162        bh._128 = esimd<8>::mergeh(U16h[i], U16l[i]);
163        #endif
164
165        bitblock::store_unaligned(bl._128, reinterpret_cast<BytePack *>(contentStreamPtr));
166        contentStreamPtr += del._8[i << 1];
167
168        bitblock::store_unaligned(bh._128, reinterpret_cast<BytePack *>(contentStreamPtr));
169        contentStreamPtr += del._8[(i << 1) | 1];
170    }
171
172        const bool hasStrings = bitblock::any(callouts.StringEnds);
173        ubitblock refMarks;
174        refMarks._128 = simd_or(marker.Ref_opener, marker.Ref_closer);
175        const bool hasRefs = bitblock::any(refMarks._128);
176        if (likely(hasStrings | hasRefs))
177        {
178                /* --------------------------------------------------------------------- */
179                /* CALCULATE PARTIAL SUM OF DELETED CHARACTERS
180                /* --------------------------------------------------------------------- */
181
182                del._128 = simd<8>::sub(simd<8>::constant<8>(), del._128);
183                del._128 = simd<8>::add(del._128, mvmd<8>::slli<1>(del._128));
184                del._128 = simd<8>::add(del._128, mvmd<8>::slli<2>(del._128));
185                del._128 = simd<8>::add(del._128, mvmd<8>::slli<4>(del._128));
186                del._128 = simd<8>::add(del._128, mvmd<8>::slli<8>(del._128));
187                del._128 = mvmd<8>::slli<1>(del._128);
188
189                /* (i.e., if del._8 was initially { 0, 1, 2, 3, 4, ... } it will now be
190                   {8, 15, 21, 26, 30, ... }) */
191
192                // do we have space for at least (BLOCK_SIZE / 2) more strings? (the maximum possible)
193
194                /* --------------------------------------------------------------------- */
195                /* STRING END SPACE CALCULATION
196                /* --------------------------------------------------------------------- */
197                if (unlikely((stringEndPtr + (BLOCK_SIZE / 2)) >= stringEndArray.limit()))
198                {
199                        XMLSize_t stringEndOffset = stringEndPtr - &stringEndArray[0];
200                        stringEndArray.expand(stringEndOffset);
201                        stringEndPtr = &stringEndArray[stringEndOffset];
202                }
203
204                /* --------------------------------------------------------------------- */
205                /* STRING LENGTH CALCULATIONS
206                /* --------------------------------------------------------------------- */
207                if (likely(hasStrings))
208                {
209                        ubitblock stringEnds;
210                        stringEnds._128 = callouts.StringEnds;
211                        do_right8_shifts(stringEnds._128, shift1, shift2, shift4);
212                        XMLStreamIterator stringEndItr(stringEnds);
213                        size_t pos;
214
215                        while (stringEndItr.next(pos))
216                        {
217                                pos -= del._8[pos >> 3];
218                                *stringEndPtr++ = (contentStreamPtr0 + pos);
219                        }
220                }
221
222                /* --------------------------------------------------------------------- */
223                /* HANDLE REF REPLACEMENTS
224                /* --------------------------------------------------------------------- */
225
226                if (unlikely(hasRefs))
227                {
228                        ubitblock refStart;
229                        refStart._128 = marker.Ref_opener;
230                        do_right8_shifts(refStart._128, shift1, shift2, shift4);
231
232                        ubitblock attValSpan;
233                        attValSpan._128 = callouts.AttValSpan;
234
235                        fReferenceTable.findAndExpandRefs<2>
236                        (
237                                refMarks
238                                , source
239                                , offset
240                                , refStart
241                                , contentStreamPtr0 - &contentStream[0]
242                                , del
243                                , attValSpan
244                                , const_cast<XMLScanner*>(fScanner)
245                                , fSymbolTable
246                                , contentStream
247                                , contentStreamPtr
248                                , stringEndArray
249                                , stringEndPtr
250                                , refMarkupCount
251                                , refSymbolCount
252                                , complexRefArray
253                                , complexRefCount
254                        );
255
256                }
257        }
258        return contentStreamPtr;
259}
260
261// ---------------------------------------------------------------------------
262//  XMLUTF8CharacterSetAdapter: Implementation of the transcoder API
263// ---------------------------------------------------------------------------
264
265XMLCh * XMLUTF16CharacterSetAdapter::parse
266(
267        const XMLByte * const           source
268        , const XMLSize_t                       offset
269        , const XMLSize_t                       avail
270        , const bool                            noMore
271        ,       ContentStream &         contentStream
272        ,           XMLSize_t                   contentOffset
273        ,       unsigned int &          markupCount
274        ,               SymbolArray &           symbolArray
275        ,               unsigned int &          symbolCount
276        ,               StringPtrArray &        stringEndArray
277        ,       unsigned int &          stringEndCount
278        ,       XMLLineColTracker &     lineColTracker
279        ,       BitBlock *                      newLineOrSkipMaskStream
280        ,       BitBlock *                      delMaskStream
281        ,       unsigned int &          incompleteMarkupBytes
282        ,       unsigned int &          unusedSymbols
283        ,       unsigned int &          unusedContent
284        ,               unsigned int &          bytesEaten
285)
286{
287        enum { LOG_2_U16_BLOCK_SIZE = LOG_2_BLOCK_SIZE + 1 };
288        BitBlock symbolEnds[BUFFER_BLOCKS];
289        BitBlock symbolStream[BUFFER_BLOCKS];
290        PopCounter<3> markupCounter;
291        XMLLineColTracker currentLineColTracker(fInternalLineColTracker);
292        XMLLineColTracker outputLineColTracker(lineColTracker);
293        BitTracker lastItem;
294       
295
296          struct Parameters parameters;
297
298  struct Basis_bits basis_bits;
299
300  struct U16hi u16hi;
301
302  struct U16lo u16lo;
303
304  struct Lex lex;
305
306  struct Marker marker;
307
308  struct Callouts callouts;
309
310  struct Errors errors;
311
312
313
314        XMLCh * contentStreamPtr = &contentStream[contentOffset];
315        const XMLCh ** stringEndPtr = &stringEndArray[stringEndCount];
316        unsigned int refMarkupCount = 0;
317        unsigned int refSymbolCount = 0;
318        XMLComplexRefArray complexRefArray;
319        XMLSize_t complexRefCount = 0;
320        size_t index = (offset >> LOG_2_U16_BLOCK_SIZE);
321        size_t count = ((avail - offset) >> LOG_2_U16_BLOCK_SIZE);
322
323        for (; count--; index++)
324        {
325                const XMLByte * src = &source[index << LOG_2_U16_BLOCK_SIZE];
326                // transpose the byte data
327                transpose(reinterpret_cast<const BytePack *>(src), u16hi, u16lo, fSwapped);
328
329               
330  init_Parameters.do_block(parameters);
331  classify_bytes.do_block(parameters, u16hi, u16lo, lex, callouts, errors);
332  parse_CtCDPI.do_block(lex, marker, callouts, errors);
333  parse_tags.do_block(lex, marker, callouts, errors);
334  parse_refs.do_block(lex, marker, callouts, errors);
335  check_CD_end_error.do_block(marker, callouts, errors);
336  normalize_WS.do_block(parameters, lex, u16hi, u16lo, callouts, marker);
337  prepare_content_buffer.do_block(u16hi, u16lo, lex, callouts, marker);
338
339                bitblock::store_aligned(callouts.Symbol_ends, &symbolEnds[index]);
340                // merge the symbol start and end streams together
341                bitblock::store_aligned(simd_or(callouts.Symbol_starts, callouts.Symbol_ends), &symbolStream[index]);
342
343                currentLineColTracker.next(lex.LF, callouts.skipmask);
344                markupCounter.tally(callouts.MarkupDelimiters);
345
346                // line/col tracking streams (for error reporting)
347                bitblock::store_aligned(simd_or(lex.LF, callouts.skipmask), &newLineOrSkipMaskStream[index]);
348                bitblock::store_aligned(callouts.delmask, &delMaskStream[index]);
349
350                // scan for errors
351                checkErrors(errors, src, currentLineColTracker);
352
353                // append the new tagged content to the content buffer
354                contentStreamPtr = buildOutputStream
355                (
356                         marker
357                         , callouts
358                         , u16hi
359                         , u16lo
360                         , source
361                         , index << LOG_2_U16_BLOCK_SIZE
362                         , contentStream
363                         , contentStreamPtr
364                         , stringEndArray
365                         , stringEndPtr
366                         , refMarkupCount
367                         , refSymbolCount
368                         , complexRefArray
369                         , complexRefCount
370                );
371
372                if (lastItem.append(simd_or(callouts.MarkupDelimiters, marker.LAngle)))
373                {
374                        outputLineColTracker = currentLineColTracker;
375                }
376                currentLineColTracker.advance();
377        }
378
379        if (unlikely(noMore))
380        {
381                // will happen only once per document
382                const scanword_t advance = avail & ((BLOCK_SIZE * 2) - 1);
383        // if (likely((advance) || (parse_refs.carryQ.CarryTest(0, 3) || parse_tags.carryQ.CarryTest(0, 15) || parse_CtCDPI.carryQ.CarryTest(0, 19) || prepare_content_buffer.carryQ.CarryTest(0, 2)) || (classify_bytes.carryQ.CarryTest(0, 1) || normalize_WS.carryQ.CarryTest(0, 2))))
384                {
385                        const XMLByte * src = &source[index << LOG_2_U16_BLOCK_SIZE];
386                        // determine the eof mask
387                        const BitBlock EOF_mask = maskre(advance >> 1);
388                        // transpose the byte data and mask off any characters that are beyond the EOF mask
389                        transpose(reinterpret_cast<const BytePack *>(src), u16hi, u16lo, EOF_mask, fSwapped);
390
391                       
392  init_Parameters.do_final_block(parameters, EOF_mask);
393  classify_bytes.do_final_block(parameters, u16hi, u16lo, lex, callouts, errors, EOF_mask);
394  parse_CtCDPI.do_final_block(lex, marker, callouts, errors, EOF_mask);
395  parse_tags.do_final_block(lex, marker, callouts, errors, EOF_mask);
396  parse_refs.do_final_block(lex, marker, callouts, errors, EOF_mask);
397  check_CD_end_error.do_final_block(marker, callouts, errors, EOF_mask);
398  normalize_WS.do_final_block(parameters, lex, u16hi, u16lo, callouts, marker, EOF_mask);
399  prepare_content_buffer.do_final_block(u16hi, u16lo, lex, callouts, marker, EOF_mask);
400
401                        bitblock::store_aligned(callouts.Symbol_ends, &symbolEnds[index]);
402                        // merge the symbol start and end streams together
403                        bitblock::store_aligned(simd_or(callouts.Symbol_starts, callouts.Symbol_ends), &symbolStream[index]);
404
405                        callouts.delmask = simd_or(callouts.delmask, simd_not(EOF_mask));
406                        currentLineColTracker.next(lex.LF, callouts.skipmask);
407                        markupCounter.tally(callouts.MarkupDelimiters);
408
409                        // line/col tracking streams (for error reporting)
410                        bitblock::store_aligned(simd_or(lex.LF, callouts.skipmask), &newLineOrSkipMaskStream[index]);
411                        bitblock::store_aligned(callouts.delmask, &delMaskStream[index]);
412
413                        // scan for errors
414                        checkErrors(errors, src, currentLineColTracker);
415
416                        // append the new tagged content to the content buffer
417                        contentStreamPtr = buildOutputStream
418                        (
419                                 marker
420                                 , callouts
421                                 , u16hi
422                                 , u16lo
423                                 , source
424                                 , index << LOG_2_U16_BLOCK_SIZE
425                                 , contentStream
426                                 , contentStreamPtr
427                                 , stringEndArray
428                                 , stringEndPtr
429                                 , refMarkupCount
430                                 , refSymbolCount
431                                 , complexRefArray
432                                 , complexRefCount
433                        );
434
435                        if (lastItem.append(simd_or(callouts.MarkupDelimiters, marker.LAngle)))
436                        {
437                                outputLineColTracker = currentLineColTracker;
438                        }
439                        currentLineColTracker.advance();
440                        index++;
441                }
442        }
443
444        if (likely(complexRefCount == 0))
445        {
446                // process the symbols and generate the gid array
447                symbolCount = fSymbolTable->resolve<2>
448                (
449                        symbolStream
450                        , source
451                        , (offset >> LOG_2_U16_BLOCK_SIZE)
452                        , index
453                        , symbolCount
454                        , symbolArray
455                );
456        }
457        else
458        {
459                // if we're adding in complex refs, then we cannot be sure whether or not the symbol stream
460                // will have room for them all. tally up the document's symbols and add them to the refSymbolCount
461                symbolCount = fSymbolTable->resolve<2>
462                (
463                        symbolStream
464                        , source
465                        , (offset >> LOG_2_U16_BLOCK_SIZE)
466                        , index
467                        , symbolCount
468                        , symbolArray
469                        , complexRefArray
470                        , complexRefCount
471                        , refSymbolCount
472                        , fReferenceTable
473                );
474        }
475
476        // if partial symbol or ref exists, then calculate the unused raw data
477        bytesEaten = avail;
478        if (fSymbolTable->fResumeSymbol)
479        {
480                bytesEaten = fSymbolTable->fStartPosition;
481                fSymbolTable->fStartPosition &= ((BLOCK_SIZE * 2) - 1);
482        }
483        #ifdef TEST_ENTITY_EXPANSION
484        else if (fReferenceTable.fResumeRef)
485        {
486                fReferenceTable.fRefStartPosition = 0;
487                bytesEaten = fReferenceTable.fStartPosition;
488                fReferenceTable.fStartPosition &= ((BLOCK_SIZE * 2) - 1);
489        }
490        #endif
491
492        // collapse the skip mask information into a fixed line/col # to pass to the parser
493        const unsigned int unusedMarkupBytes = lastItem.distance();
494
495        XMLFileLoc line, col;
496        const unsigned int pos = BLOCK_SIZE - (unusedMarkupBytes & (BLOCK_SIZE - 1));
497        outputLineColTracker.get(pos, line, col);
498        lineColTracker.set(line, col);
499        // store the current line/col for the next iteration
500        fInternalLineColTracker = currentLineColTracker;
501        #ifdef CALCULATE_COPY_BACK_POSITION
502        // determine how many symbols / bytes of content will not be used
503        if (unlikely(unusedMarkupBytes == avail))
504        {
505                unusedSymbols += symbolCount;
506                unusedContent += (contentStreamPtr - &contentStream[0]);
507                incompleteMarkupBytes += unusedMarkupBytes;
508        }
509        else
510        {
511                unusedSymbols = calculateUnusedSymbols(symbolEnds, avail, unusedMarkupBytes);
512                unusedContent = calculateUnusedContent(delMaskStream, avail, unusedMarkupBytes);
513                incompleteMarkupBytes = unusedMarkupBytes;
514        }
515        #else
516        incompleteMarkupBytes = unusedMarkupBytes;
517        #endif
518        // calculate how many strings (content, attvals, comments, pis) are in this buffer.
519        *contentStreamPtr = 0xFFFF;
520        *stringEndPtr = contentStreamPtr;
521        stringEndCount = stringEndPtr - &stringEndArray[0];
522        // calculate exactly how many pieces of markup are contained in the content buffer
523        markupCount = markupCounter.count() + refMarkupCount;
524
525        // return the final content end pointer
526        return contentStreamPtr;
527}
528
529
530IDISA_ALWAYS_INLINE
531XMLCh * XMLUTF16CharacterSetAdapter::buildInternalOutputStream
532(
533        const Marker    &                       marker
534        , const Callouts  &                     callouts
535        ,       U16hi     &         u16hi
536        ,       U16lo     &         u16lo
537        , const XMLCh *                         source
538        ,       XMLCh *                         contentStreamPtr
539        ,               StringPtrArray &        stringEndArray
540        , const XMLCh     ** &      stringEndPtr
541)
542{
543        BitBlock shift1, shift2, shift4;
544        del_info_8(callouts.delmask, shift1, shift2, shift4);
545        ubitblock del;
546        del_count(callouts.delmask, del._128);
547
548        BytePack U16h[8];
549        BytePack U16l[8];
550
551        do_right8_shifts(u16lo.bit_0, shift1, shift2, shift4);
552        do_right8_shifts(u16lo.bit_1, shift1, shift2, shift4);
553        do_right8_shifts(u16lo.bit_2, shift1, shift2, shift4);
554        do_right8_shifts(u16lo.bit_3, shift1, shift2, shift4);
555        do_right8_shifts(u16lo.bit_4, shift1, shift2, shift4);
556        do_right8_shifts(u16lo.bit_5, shift1, shift2, shift4);
557        do_right8_shifts(u16lo.bit_6, shift1, shift2, shift4);
558        do_right8_shifts(u16lo.bit_7, shift1, shift2, shift4);
559        do_right8_shifts(u16hi.bit_0, shift1, shift2, shift4);
560        do_right8_shifts(u16hi.bit_1, shift1, shift2, shift4);
561        do_right8_shifts(u16hi.bit_2, shift1, shift2, shift4);
562        do_right8_shifts(u16hi.bit_3, shift1, shift2, shift4);
563        do_right8_shifts(u16hi.bit_4, shift1, shift2, shift4);
564        do_right8_shifts(u16hi.bit_5, shift1, shift2, shift4);
565        do_right8_shifts(u16hi.bit_6, shift1, shift2, shift4);
566        do_right8_shifts(u16hi.bit_7, shift1, shift2, shift4);
567
568        p2s(u16lo.bit_0,u16lo.bit_1,u16lo.bit_2,u16lo.bit_3,u16lo.bit_4,u16lo.bit_5,u16lo.bit_6,u16lo.bit_7,
569                U16l[0], U16l[1],U16l[2] ,U16l[3] ,U16l[4] ,U16l[5] ,U16l[6] ,U16l[7]);
570
571        p2s(u16hi.bit_0,u16hi.bit_1,u16hi.bit_2,u16hi.bit_3,u16hi.bit_4,u16hi.bit_5,u16hi.bit_6,u16hi.bit_7,
572                U16h[0], U16h[1],U16h[2] ,U16h[3] ,U16h[4] ,U16h[5] ,U16h[6] ,U16h[7]);
573
574        /* --------------------------------------------------------------------- */
575        /* WRITE THE CONTENT STREAM
576        /* --------------------------------------------------------------------- */
577
578        XMLCh * contentStreamPtr0 = contentStreamPtr;
579    for (unsigned int i = 0; i < 8; i++)
580    {
581        ubitblock bl;
582        ubitblock bh;
583
584        #ifdef USE_UTF16_BIG_ENDIAN
585        bl._128 = esimd<8>::mergel(U16l[i], U16h[i]);
586        bh._128 = esimd<8>::mergeh(U16l[i], U16h[i]);
587        #else
588        bl._128 = esimd<8>::mergel(U16h[i], U16l[i]);
589        bh._128 = esimd<8>::mergeh(U16h[i], U16l[i]);
590        #endif
591
592        bitblock::store_unaligned(bl._128, reinterpret_cast<BytePack *>(contentStreamPtr));
593        contentStreamPtr += del._8[i << 1];
594
595        bitblock::store_unaligned(bh._128, reinterpret_cast<BytePack *>(contentStreamPtr));
596        contentStreamPtr += del._8[(i << 1) | 1];
597    }
598
599
600        const bool hasStrings = bitblock::any(callouts.StringEnds);
601        const bool hasRefs = bitblock::any(marker.Ref_opener);
602        if (likely(hasStrings | hasRefs))
603        {
604                /* --------------------------------------------------------------------- */
605                /* CALCULATE PARTIAL SUM OF DELETED CHARACTERS
606                /* --------------------------------------------------------------------- */
607
608                del._128 = simd<8>::sub(simd<8>::constant<8>(), del._128);
609                del._128 = simd<8>::add(del._128, mvmd<8>::slli<1>(del._128));
610                del._128 = simd<8>::add(del._128, mvmd<8>::slli<2>(del._128));
611                del._128 = simd<8>::add(del._128, mvmd<8>::slli<4>(del._128));
612                del._128 = simd<8>::add(del._128, mvmd<8>::slli<8>(del._128));
613                del._128 = mvmd<8>::slli<1>(del._128);
614
615                /* (i.e., if del._8 was initially { 0, 1, 2, 3, 4, ... } it will now be
616                   {8, 15, 21, 26, 30, ... }) */
617
618                /* --------------------------------------------------------------------- */
619                /* STRING LENGTH CALCULATIONS
620                /* --------------------------------------------------------------------- */
621                if (likely(hasStrings))
622                {
623                        ubitblock stringEnds;
624                        stringEnds._128 = callouts.StringEnds;
625                        do_right8_shifts(stringEnds._128, shift1, shift2, shift4);
626                        XMLStreamIterator stringEndItr(stringEnds);
627                        size_t pos;
628
629                        while (stringEndItr.next(pos))
630                        {
631                                pos -= del._8[pos >> 3];
632                                *stringEndPtr++ = (contentStreamPtr0 + pos);
633                        }
634                }
635
636                /* --------------------------------------------------------------------- */
637                /* HANDLE REF REPLACEMENTS (ONLY CHAR REFS AND PRE-DEFINED ENTITIES)
638                /* --------------------------------------------------------------------- */
639
640                if (unlikely(hasRefs))
641                {
642            ubitblock refContent;
643                        ubitblock refOpener;
644                        refContent._128 = marker.Ref_opener;
645                        refOpener._128 = marker.Ref_opener;
646                        do_right8_shifts(refContent._128, shift1, shift2, shift4);
647                        XMLStreamIterator refOpenerItr(refOpener, CONST_LOG_2(1));
648                        XMLStreamIterator refContentItr(refContent, CONST_LOG_2(1));
649
650                        size_t pos;
651
652                        while (refOpenerItr.next(pos))
653                        {
654                                assert (source[pos] == chAmpersand);
655
656                                const XMLCh * entityRef = &source[pos + 1];
657
658                                // calculate the content buffer offset
659                                size_t offset = 0;
660                                refContentItr.next(offset);
661                                offset -= del._8[offset >> 3];
662
663                                XMLCh * contentRef = &contentStreamPtr0[offset];
664
665                                if (*entityRef == chPound)
666                                {
667                                        XMLCh charVal[2];
668                                        XMLSize_t len = fScanner->expandCharRef(entityRef + 1, &charVal[0], chSemiColon);
669                                        if (likely(len == 1))
670                                        {
671                                                *contentRef = charVal[0];
672                                        }
673                                        else if (len == 2)
674                                        {
675                                                assert (!"NOT HANDLED YET!");
676                                        }
677                                }
678                                else
679                                {
680                                        // pre-defined
681                                        // TODO: simd-ize the comparisons? would this help or hinder performance?
682
683                                        switch (*entityRef)
684                                        {
685                                                case chLatin_a: //amp | apos
686                                                        if (likely(entityRef[1] == chLatin_m)) //amp
687                                                        {
688                                                                if (likely((entityRef[2] == chLatin_p) && (entityRef[3] == chSemiColon)))
689                                                                {
690                                                                        *contentRef = chAmpersand;
691                                                                }
692                                                        }
693                                                        else if (entityRef[1] == chLatin_p) //apos
694                                                        {
695                                                                if (likely((entityRef[2] == chLatin_o) && (entityRef[3] == chLatin_s) && (entityRef[4] == chSemiColon)))
696                                                                {
697                                                                        *contentRef = chSingleQuote;
698                                                                }
699                                                        }
700                                                        break;
701                                                case chLatin_g: //gt
702                                                        if (likely((entityRef[1] == chLatin_t) && (entityRef[2] == chSemiColon)))
703                                                        {
704                                                                *contentRef = chCloseAngle;
705                                                        }
706                                                        break;
707                                                case chLatin_l: //lt
708                                                        if (likely((entityRef[1] == chLatin_t) && (entityRef[2] == chSemiColon)))
709                                                        {
710                                                                *contentRef = chOpenAngle;
711                                                        }
712                                                        break;
713                                                case chLatin_q: //quot
714                                                        if (likely((entityRef[1] == chLatin_u) && (entityRef[2] == chLatin_o) && (entityRef[3] == chLatin_t) && (entityRef[4] == chSemiColon)))
715                                                        {
716                                                                *contentRef = chDoubleQuote;
717                                                        }
718                                                        break;
719                                                default:
720                                                        UNREACHABLE
721                                        }
722                                }
723
724
725
726                        }
727
728                }
729        }
730
731        return contentStreamPtr;
732}
733
734XMLSize_t XMLUTF16CharacterSetAdapter::parseInternal
735(
736        const XMLByte * const           source
737        , const XMLSize_t                       avail
738        ,       ContentStream &         contentStream
739        ,       unsigned int &          markupCount
740        ,               SymbolArray &           symbolArray
741        ,               unsigned int &          symbolCount
742        ,               StringPtrArray &        stringEndArray
743        ,       unsigned int &          stringEndCount
744)
745{
746        enum { LOG_2_U16_BLOCK_SIZE = LOG_2_BLOCK_SIZE + 1 };
747        PopCounter<3> markupCounter;
748        XMLLineColTracker currentLineColTracker;
749       
750
751          struct Parameters parameters;
752
753  struct Basis_bits basis_bits;
754
755  struct U16hi u16hi;
756
757  struct U16lo u16lo;
758
759  struct Lex lex;
760
761  struct Marker marker;
762
763  struct Callouts callouts;
764
765  struct Errors errors;
766
767
768
769        XMLCh * contentStreamPtr = &contentStream[0];
770        const XMLCh ** stringEndPtr = &stringEndArray[0];
771
772        size_t index = 0;
773        size_t count = (avail >> LOG_2_U16_BLOCK_SIZE);
774
775        BitBlock * const symbolStream = Array<BitBlock>::allocate(count + 1);
776
777        for (; count--; index++)
778        {
779                const XMLByte * src = &source[index << LOG_2_U16_BLOCK_SIZE];
780
781        #ifdef PRINT_DEBUG_MESSAGE
782        XMLCh srcData[BLOCK_SIZE + 1] = {0};
783        memcpy(srcData, src, BLOCK_SIZE * sizeof(XMLCh));
784        for (XMLSize_t i = 0; i < BLOCK_SIZE; i++)
785        {
786            if (srcData[i] < 0x20) srcData[i] = 0x20;
787        }
788        DEBUG_MESSAGE(srcData);
789        #endif
790
791                // transpose the byte data
792                transpose(reinterpret_cast<const BytePack *>(src), u16hi, u16lo, 0);
793
794               
795  init_Parameters.do_block(parameters);
796  classify_bytes.do_block(parameters, u16hi, u16lo, lex, callouts, errors);
797  parse_CtCDPI.do_block(lex, marker, callouts, errors);
798  parse_tags.do_block(lex, marker, callouts, errors);
799  parse_refs.do_block(lex, marker, callouts, errors);
800  check_CD_end_error.do_block(marker, callouts, errors);
801  normalize_WS.do_block(parameters, lex, u16hi, u16lo, callouts, marker);
802  prepare_content_buffer.do_block(u16hi, u16lo, lex, callouts, marker);
803
804                // merge the symbol start and end streams together
805                bitblock::store_aligned(simd_or(callouts.Symbol_starts, callouts.Symbol_ends), &symbolStream[index]);
806
807                currentLineColTracker.next(lex.LF, callouts.skipmask);
808                markupCounter.tally(callouts.MarkupDelimiters);
809
810                // scan for errors
811                checkErrors(errors, src, currentLineColTracker);
812
813                // append the new tagged content to the content buffer
814                contentStreamPtr = buildInternalOutputStream
815                (
816                         marker
817                         , callouts
818                         , u16hi
819                         , u16lo
820                         , (const XMLCh *)&source[index << LOG_2_U16_BLOCK_SIZE]
821                         , contentStreamPtr
822                         , stringEndArray
823                         , stringEndPtr
824                );
825
826                currentLineColTracker.advance();
827        }
828
829        // will happen only once per document
830        const scanword_t advance = avail & ((BLOCK_SIZE * 2) - 1);
831        if (likely((advance) || (parse_refs.carryQ.CarryTest(0, 3) || parse_tags.carryQ.CarryTest(0, 15) || parse_CtCDPI.carryQ.CarryTest(0, 19) || prepare_content_buffer.carryQ.CarryTest(0, 2)) || (classify_bytes.carryQ.CarryTest(0, 1) || normalize_WS.carryQ.CarryTest(0, 2))))
832        {
833                const XMLByte * src = &source[index << LOG_2_U16_BLOCK_SIZE];
834                // determine the eof mask
835                const BitBlock EOF_mask = maskre(advance >> 1);
836                // transpose the byte data and mask off any characters that are beyond the EOF mask
837                transpose(reinterpret_cast<const BytePack *>(src), u16hi, u16lo, EOF_mask, 0);
838
839               
840  init_Parameters.do_final_block(parameters, EOF_mask);
841  classify_bytes.do_final_block(parameters, u16hi, u16lo, lex, callouts, errors, EOF_mask);
842  parse_CtCDPI.do_final_block(lex, marker, callouts, errors, EOF_mask);
843  parse_tags.do_final_block(lex, marker, callouts, errors, EOF_mask);
844  parse_refs.do_final_block(lex, marker, callouts, errors, EOF_mask);
845  check_CD_end_error.do_final_block(marker, callouts, errors, EOF_mask);
846  normalize_WS.do_final_block(parameters, lex, u16hi, u16lo, callouts, marker, EOF_mask);
847  prepare_content_buffer.do_final_block(u16hi, u16lo, lex, callouts, marker, EOF_mask);
848
849                // merge the symbol start and end streams together
850                bitblock::store_aligned(simd_or(callouts.Symbol_starts, callouts.Symbol_ends), &symbolStream[index]);
851
852                callouts.delmask = simd_or(callouts.delmask, simd_not(EOF_mask));
853                currentLineColTracker.next(lex.LF, callouts.skipmask);
854                markupCounter.tally(callouts.MarkupDelimiters);
855
856                // scan for errors
857                checkErrors(errors, src, currentLineColTracker);
858
859                // append the new tagged content to the content buffer
860                contentStreamPtr = buildInternalOutputStream
861                (
862                         marker
863                         , callouts
864                         , u16hi
865                         , u16lo
866                         , (const XMLCh *)&source[index << LOG_2_U16_BLOCK_SIZE]
867                         , contentStreamPtr
868                         , stringEndArray
869                         , stringEndPtr
870                );
871
872                currentLineColTracker.advance();
873                index++;
874        }
875
876        // process the symbols and generate the gid array
877        symbolCount = fSymbolTable->resolve<2>(symbolStream, source, 0, index, symbolCount, symbolArray, 1);
878
879        // destroy the symbol stream memory now that we're finished with it
880        Array<BitBlock>::deallocate(symbolStream);
881
882        // calculate how many strings (content, attvals, comments, pis) are in this buffer.
883        *contentStreamPtr = 0xFFFF;
884        *stringEndPtr = contentStreamPtr;
885        stringEndCount = stringEndPtr - &stringEndArray[0];
886        // calculate exactly how many pieces of markup are contained in the content buffer
887        markupCount = markupCounter.count();
888
889        // return the final content end pointer
890        return contentStreamPtr - &contentStream[0];
891}
892
893#ifdef CALCULATE_COPY_BACK_POSITION
894IDISA_ALWAYS_INLINE
895uint64_t XMLUTF16CharacterSetAdapter::calculateUnusedSymbols
896(
897        const BitBlock * const  symbolStream
898        , const unsigned int    avail
899        , const unsigned int    unused
900)
901{
902        PopCounter<1> symbolCounter;
903        unsigned int index = ((avail - unused) >> LOG_2_BLOCK_SIZE);
904        unsigned int count = (avail >> LOG_2_BLOCK_SIZE);
905        BitBlock symbols =
906                simd_andc(bitblock::load_aligned(&symbolStream[index]), mask_reverse_zeroes(unused & (BLOCK_SIZE - 1)));
907        symbolCounter.tally(symbols);
908        for (++index; unlikely(index < count); index++)
909        {
910                symbols = bitblock::load_aligned(&symbolStream[index]);
911                symbolCounter.tally(symbols);
912        }
913        return symbolCounter.count();
914}
915
916IDISA_ALWAYS_INLINE
917uint64_t XMLUTF16CharacterSetAdapter::calculateUnusedContent
918(
919        const BitBlock * const  delMaskStream
920        , const unsigned int    avail
921        , const unsigned int    unused
922)
923{
924        unsigned int index = (avail + (BLOCK_SIZE - 1)) >> LOG_2_BLOCK_SIZE;
925        size_t markupCount = (unused >> LOG_2_BLOCK_SIZE);
926        size_t unusedContent = unused;
927
928        while (unlikely(markupCount != 0))
929        {
930                markupCount--;
931                BitBlock delMask = bitblock::load_aligned(&delMaskStream[--index]);
932                ubitblock pop;
933                pop._128 = simd128<64>::popcount(delMask);
934                unusedContent -= (pop._64[0] + pop._64[1]);
935        }
936
937        markupCount = unused & (BLOCK_SIZE - 1);
938
939        if (likely(markupCount != 0))
940        {
941                unsigned int pos = (128 / 8) - 1;
942                ubitblock pop;
943                ubitblock del;
944                del._128 = bitblock::load_aligned(&delMaskStream[--index]);
945                pop._128 = simd128<8>::popcount(del._128);
946
947                index = (markupCount >> CONST_LOG_2(8));
948
949                for (; index; --pos, --index)
950                {
951                        unusedContent -= pop._8[pos];
952                }
953
954                // at most 7 markup bytes are remaining
955                markupCount &= (8 - 1);
956
957                if (likely(markupCount != 0))
958                {
959                        const scanword_t one = 1;
960                        scanword_t itr = del._8[pos];
961                        itr &= ~((one << (8 - markupCount)) - one);
962                        while (itr)
963                        {
964                                itr &= (itr - 1);
965                                unusedContent--;
966                        }
967                }
968        }
969
970        return unusedContent;
971}
972#endif
973
974#undef do_right8_shifts
975
976IDISA_ALWAYS_INLINE
977void XMLUTF16CharacterSetAdapter::checkErrors(const XMLUTF16CharacterSetAdapter::Errors & errors, const XMLByte * source, XMLLineColTracker & lineCol)
978{
979        BitBlock temp0 = simd_or(errors.Unicode, errors.Lexical);
980        BitBlock temp1 = simd_or(errors.ExpectedCommentOrCDATA, errors.PINameExpected);
981        BitBlock temp2 = simd_or(errors.UnterminatedPI, errors.IllegalSequenceInComment);
982        BitBlock temp3 = simd_or(errors.UnterminatedCDATASection, errors.UnterminatedComment);
983        BitBlock temp4 = simd_or(errors.ExpectedElementName, errors.ExpectedAttrName);
984        BitBlock temp5 = simd_or(errors.ExpectedEqSign, errors.ExpectedAttrValue);
985        BitBlock temp6 = simd_or(errors.UnterminatedStartTag, errors.ExpectedWhitespace);
986        BitBlock temp7 = simd_or(errors.UnterminatedEndTag, errors.UnterminatedEntityRef);
987
988        temp0 = simd_or(temp0, temp1);
989        temp2 = simd_or(temp2, temp3);
990        temp4 = simd_or(temp4, temp5);
991        temp6 = simd_or(temp6, temp7);
992
993        temp0 = simd_or(temp0, temp2);
994        temp4 = simd_or(temp4, temp6);
995
996        temp0 = simd_or(temp0, temp4);
997
998        const BitBlock fatalErrors = simd_or(temp0, errors.BadSequenceInCharData);
999
1000        // does at least one error exist? all of these are fatal errors in Xerces so we only need to check one
1001        if (unlikely(bitblock::any(fatalErrors)))
1002        {
1003                reportError(fatalErrors, errors, source, lineCol);
1004        }
1005}
1006
1007void XMLUTF16CharacterSetAdapter::reportError(const BitBlock fatalErrors, const XMLUTF16CharacterSetAdapter::Errors & errors, const XMLByte * source, XMLLineColTracker & lineCol)
1008{
1009    const size_t fatalErrorPosition = count_forward_zeroes(fatalErrors);
1010    const BitBlock fatalErrorMask = mask_forward_zeroes(fatalErrorPosition);
1011
1012    DEBUG_MESSAGE(" ==================== FATAL ERROR ========================")
1013
1014    DEBUG_MESSAGE("errors.Unicode=" << errors.Unicode)
1015    DEBUG_MESSAGE("errors.Lexical=" << errors.Lexical)
1016    DEBUG_MESSAGE("errors.ExpectedCommentOrCDATA=" << errors.ExpectedCommentOrCDATA)
1017    DEBUG_MESSAGE("errors.PINameExpected=" << errors.PINameExpected)
1018    DEBUG_MESSAGE("errors.UnterminatedPI=" << errors.UnterminatedPI)
1019    DEBUG_MESSAGE("errors.IllegalSequenceInComment=" << errors.IllegalSequenceInComment)
1020    DEBUG_MESSAGE("errors.UnterminatedCDATASection=" << errors.UnterminatedCDATASection)
1021    DEBUG_MESSAGE("errors.UnterminatedComment=" << errors.UnterminatedComment)
1022    DEBUG_MESSAGE("errors.ExpectedElementName=" << errors.ExpectedElementName)
1023    DEBUG_MESSAGE("errors.ExpectedAttrName=" << errors.ExpectedAttrName)
1024    DEBUG_MESSAGE("errors.ExpectedEqSign=" << errors.ExpectedEqSign)
1025    DEBUG_MESSAGE("errors.ExpectedAttrValue=" << errors.ExpectedAttrValue)
1026    DEBUG_MESSAGE("errors.UnterminatedStartTag=" << errors.UnterminatedStartTag)
1027    DEBUG_MESSAGE("errors.ExpectedWhitespace=" << errors.ExpectedWhitespace)
1028    DEBUG_MESSAGE("errors.UnterminatedEndTag=" << errors.UnterminatedEndTag)
1029    DEBUG_MESSAGE("errors.UnterminatedEntityRef=" << errors.UnterminatedEntityRef)
1030
1031        if (bitblock::any(simd_and(errors.Lexical, fatalErrorMask)))
1032        {
1033                // ------------------------------------------------------------
1034                // ILLEGAL XML CHARACTER
1035                // ------------------------------------------------------------
1036                // note: this is a guess for now as to what the real error code should be
1037
1038                ThrowXMLwithMemMgr(TranscodingException, XMLExcepts::Trans_BadSrcSeq, getMemoryManager());
1039        }
1040        else
1041        {
1042                XMLErrs::Codes errCode = XMLErrs::NoError;
1043                // calculate the line/col of this error
1044                XMLFileLoc line, col;
1045                lineCol.get(fatalErrorPosition, line, col);
1046
1047                if (bitblock::any(simd_and(errors.Unicode, fatalErrorMask)))
1048                {
1049                        // ------------------------------------------------------------
1050                        // ILLEGAL UTF16 SURROGATE PAIR
1051                        // ------------------------------------------------------------
1052                        const XMLCh nextCh = reinterpret_cast<const XMLCh*>(source)[fatalErrorPosition];
1053                        if ((nextCh >= 0xD800) && (nextCh <= 0xDBFF))
1054                        {
1055                                //  Its a leading surrogate but the trailing surrogate is missing; ergo, we're still expecting it
1056                                errCode = XMLErrs::Expected2ndSurrogateChar;
1057                        }
1058                        else if ((nextCh < 0xDC00) || (nextCh > 0xDFFF))
1059                        {
1060                                //  Its a trailing surrogate, but we are not expecting it
1061                                errCode = XMLErrs::Unexpected2ndSurrogateChar;
1062                        }
1063                }
1064                else if (bitblock::any(simd_and(errors.ExpectedCommentOrCDATA, fatalErrorMask)))
1065                {
1066                        errCode = XMLErrs::ExpectedCommentOrCDATA;
1067                }
1068                else if (bitblock::any(simd_and(errors.PINameExpected, fatalErrorMask)))
1069                {
1070                        errCode = XMLErrs::PINameExpected;
1071                }
1072                else if (bitblock::any(simd_and(errors.UnterminatedPI, fatalErrorMask)))
1073                {
1074                        errCode = XMLErrs::UnterminatedPI;
1075                }
1076                else if (bitblock::any(simd_and(errors.IllegalSequenceInComment, fatalErrorMask)))
1077                {
1078                        errCode = XMLErrs::IllegalSequenceInComment;
1079                }
1080                else if (bitblock::any(simd_and(errors.UnterminatedCDATASection, fatalErrorMask)))
1081                {
1082                        errCode = XMLErrs::UnterminatedCDATASection;
1083                }
1084                else if (bitblock::any(simd_and(errors.UnterminatedComment, fatalErrorMask)))
1085                {
1086                        errCode = XMLErrs::UnterminatedComment;
1087                }
1088                else if (bitblock::any(simd_and(errors.ExpectedElementName, fatalErrorMask)))
1089                {
1090                        errCode = XMLErrs::ExpectedElementName;
1091                }
1092                else if (bitblock::any(simd_and(errors.ExpectedAttrName, fatalErrorMask)))
1093                {
1094                        errCode = XMLErrs::ExpectedAttrName;
1095                }
1096                else if (bitblock::any(simd_and(errors.ExpectedEqSign, fatalErrorMask)))
1097                {
1098                        errCode = XMLErrs::ExpectedEqSign;
1099                }
1100                else if (bitblock::any(simd_and(errors.ExpectedAttrValue, fatalErrorMask)))
1101                {
1102                        errCode = XMLErrs::ExpectedAttrValue;
1103                }
1104                else if (bitblock::any(simd_and(errors.UnterminatedStartTag, fatalErrorMask)))
1105                {
1106                        errCode = XMLErrs::UnterminatedStartTag;
1107                }
1108                else if (bitblock::any(simd_and(errors.ExpectedWhitespace, fatalErrorMask)))
1109                {
1110                        errCode = XMLErrs::ExpectedWhitespace;
1111                }
1112                else if (bitblock::any(simd_and(errors.UnterminatedEndTag, fatalErrorMask)))
1113                {
1114                        errCode = XMLErrs::UnterminatedEndTag;
1115                }
1116                else if (bitblock::any(simd_and(errors.UnterminatedEntityRef, fatalErrorMask)))
1117                {
1118                        errCode = XMLErrs::UnterminatedEntityRef;
1119                }
1120                else if (bitblock::any(simd_and(errors.BadSequenceInCharData, fatalErrorMask)))
1121                {
1122                        errCode = XMLErrs::BadSequenceInCharData;
1123                }
1124
1125                fScanner->emitError(errCode, line, col);
1126        }
1127}
1128
1129XERCES_CPP_NAMESPACE_END
1130
Note: See TracBrowser for help on using the repository browser.