source: icXML/icXML-devel/src/icxmlc/XMLUTF16CharacterSetAdapter.hpp @ 2728

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

XAlignedMemory, path updates, config files

File size: 86.0 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.hpp 217 2012-12-03 15:00:50Z robc $
10 *
11 */
12
13#if !defined(XERCESC_INCLUDE_GUARD_XMLUTF16CHARACTERSETADAPTER_HPP)
14#define XERCESC_INCLUDE_GUARD_XMLUTF16CHARACTERSETADAPTER_HPP
15
16#include <xercesc/util/XercesDefs.hpp>
17#include <icxercesc/util/TransService.hpp>
18#include <icxercesc/internal/XMLReader.hpp>
19
20#include <simd-lib/s2p.hpp>
21#include <simd-lib/p2s.hpp>
22#include <simd-lib/carryQ.hpp>
23#include <icxmlc/XMLMultiliteral.h>
24#include <icxmlc/XMLLineColTracker.hpp>
25#include <icxmlc/XMLSymbolTable.hpp>
26#include <icxmlc/XMLReferenceTable.hpp>
27#include <icxmlc/XMLParserDefs.hpp>
28// #include <icxmlc/XMLErrorTracker.hpp>
29#include <icxmlc/XMLConfig.hpp>
30
31XERCES_CPP_NAMESPACE_BEGIN
32
33
34#define LocalCarryDeclare(name, count)\
35CarryArray<count, 0> name;
36
37class XMLUTF16CharacterSetAdapter : public XMLCharacterSetAdapter
38{
39public:
40
41        XMLUTF16CharacterSetAdapter
42        (
43        XMLTranscoder *             transcoder
44                , MemoryManager *                       manager
45        )
46        : XMLCharacterSetAdapter(manager)
47        , fTranscoder(transcoder)
48        #ifdef TEST_ENTITY_EXPANSION
49        , fReferenceTable(transcoder, manager)
50        #endif
51    , fSwapped(transcoder->isSwapped())
52        {
53
54        }
55
56        XMLUTF16CharacterSetAdapter
57        (
58                XMLTranscoder *                 transcoder
59                , MemoryManager *               manager
60                , bool                                  swapped
61        )
62        : XMLCharacterSetAdapter(manager)
63        , fTranscoder(transcoder)
64        #ifdef TEST_ENTITY_EXPANSION
65        , fReferenceTable(transcoder, manager)
66        #endif
67        , fSwapped(swapped)
68        {
69
70        }
71
72        virtual ~XMLUTF16CharacterSetAdapter()
73        {
74
75        }
76
77        virtual XMLSize_t getCodeUnitSize()
78        {
79                return 2;
80        }
81
82        virtual XMLCh * parse
83        (
84                const XMLByte * const           src
85                , const XMLSize_t                       offset
86                , const XMLSize_t                       avail
87                , const bool                            noMore
88                ,       ContentStream &         contentStream
89                ,           XMLSize_t                   contentOffset
90                ,       unsigned int &          markupCount
91                ,               SymbolArray &           symbolArray
92                ,               unsigned int &          symbolCount
93                ,               StringPtrArray &        stringEndArray
94                ,       unsigned int &          stringEndCount
95                ,       XMLLineColTracker &     lineColTracker
96                ,       BitBlock *                      newLineOrSkipMaskStream
97                ,       BitBlock *                      delMaskStream
98                ,       unsigned int &          incompleteMarkupBytes
99                ,       unsigned int &          unusedSymbols
100                ,       unsigned int &          unusedContent
101                ,               unsigned int &          bytesEaten
102        );
103
104        /**
105         Specialized stream-lined method for parsing resolved entities and whole
106         sub-documents.
107        **/
108        XMLSize_t parseInternal
109        (
110                const XMLByte * const           source
111                , const XMLSize_t                       avail
112                ,       ContentStream &         contentStream
113                ,       unsigned int &          markupCount
114                ,               SymbolArray &           symbolArray
115                ,               unsigned int &          symbolCount
116                ,               StringPtrArray &        stringEndArray
117                ,       unsigned int &          stringEndCount
118        );
119
120private:
121
122        // -----------------------------------------------------------------------
123        //  Unimplemented constructors and operators
124        // -----------------------------------------------------------------------
125        XMLUTF16CharacterSetAdapter(const XMLUTF16CharacterSetAdapter&);
126        XMLUTF16CharacterSetAdapter& operator=(const XMLUTF16CharacterSetAdapter&);
127
128#define error_tracker_NoteError(x, y)
129#define NoteXercesXMLErr(x, y)
130          struct Parameters {
131  BitBlock XML_11;
132};
133
134  struct Basis_bits {
135  BitBlock bit_0;
136  BitBlock bit_1;
137  BitBlock bit_2;
138  BitBlock bit_3;
139  BitBlock bit_4;
140  BitBlock bit_5;
141  BitBlock bit_6;
142  BitBlock bit_7;
143};
144
145  struct U16hi {
146  BitBlock bit_0;
147  BitBlock bit_1;
148  BitBlock bit_2;
149  BitBlock bit_3;
150  BitBlock bit_4;
151  BitBlock bit_5;
152  BitBlock bit_6;
153  BitBlock bit_7;
154};
155
156  struct U16lo {
157  BitBlock bit_0;
158  BitBlock bit_1;
159  BitBlock bit_2;
160  BitBlock bit_3;
161  BitBlock bit_4;
162  BitBlock bit_5;
163  BitBlock bit_6;
164  BitBlock bit_7;
165};
166
167  struct Lex {
168  BitBlock CR;
169  BitBlock LF;
170  BitBlock HT;
171  BitBlock SP;
172  BitBlock RefStart;
173  BitBlock Semicolon;
174  BitBlock Colon;
175  BitBlock LAngle;
176  BitBlock RAngle;
177  BitBlock LBracket;
178  BitBlock RBracket;
179  BitBlock Exclam;
180  BitBlock QMark;
181  BitBlock Hyphen;
182  BitBlock Equals;
183  BitBlock SQuote;
184  BitBlock DQuote;
185  BitBlock Slash;
186  BitBlock Hash;
187  BitBlock NameScan;
188  BitBlock Pct;
189  BitBlock RepOp;
190  BitBlock LContentDelim;
191  BitBlock WS;
192  BitBlock DEL;
193  BitBlock NEL;
194  BitBlock LS;
195};
196
197  struct Marker {
198  BitBlock LAngle;
199  BitBlock Tag_opener;
200  BitBlock Ref_opener;
201  BitBlock Ref_closer;
202  BitBlock CD_closer;
203};
204
205  struct Callouts {
206  BitBlock CtCDPI_marks;
207  BitBlock CtCDPI_closers;
208  BitBlock CtCDPI_content_starts;
209  BitBlock ctCDPI_mask;
210  BitBlock Symbol_starts;
211  BitBlock Symbol_ends;
212  BitBlock AttEq_marks;
213  BitBlock AttOpenQuotes;
214  BitBlock AttCloseQuotes;
215  BitBlock AttValSpan;
216  BitBlock StartTag_closers;
217  BitBlock EmptyTag_closers;
218  BitBlock EndTag_closers;
219  BitBlock Tag_closers;
220  BitBlock TagSpan;
221  BitBlock EndTag_marks;
222  BitBlock EmptyTag_marks;
223  BitBlock MarkupDelimiters;
224  BitBlock StringEnds;
225  BitBlock delmask;
226  BitBlock skipmask;
227};
228
229  struct Errors {
230  BitBlock Unicode;
231  BitBlock Lexical;
232  BitBlock ExpectedCommentOrCDATA;
233  BitBlock PINameExpected;
234  BitBlock UnterminatedPI;
235  BitBlock IllegalSequenceInComment;
236  BitBlock UnterminatedCDATASection;
237  BitBlock UnterminatedComment;
238  BitBlock ExpectedElementName;
239  BitBlock ExpectedAttrName;
240  BitBlock ExpectedEqSign;
241  BitBlock ExpectedAttrValue;
242  BitBlock UnterminatedStartTag;
243  BitBlock ExpectedWhitespace;
244  BitBlock UnterminatedEndTag;
245  BitBlock UnterminatedEntityRef;
246  BitBlock BadSequenceInCharData;
247};
248
249  struct Parse_refs {
250  Parse_refs() { 
251 }
252  IDISA_ALWAYS_INLINE void do_block(Lex & lex, Marker & marker, Callouts & callouts, Errors & errors) {
253                BitBlock ref_error;
254
255                BitBlock tempvar0, tempvar1;
256
257
258        marker.Ref_closer = simd<1>::constant<0>();
259        errors.UnterminatedEntityRef = simd<1>::constant<0>();
260        if ((bitblock::any(marker.Ref_opener) || carryQ.CarryTest(0, 3))) {
261          marker.Ref_closer = carryQ.BitBlock_scanthru_ci_co(marker.Ref_opener, simd_or(simd_or(lex.NameScan, marker.Ref_opener), lex.Hash), carryQ.get_carry_in(0), 0);
262          ref_error = simd_andc(marker.Ref_closer, lex.Semicolon);
263          errors.UnterminatedEntityRef = ref_error;
264          tempvar0 = carryQ.BitBlock_span_upto(marker.Ref_opener, marker.Ref_closer, carryQ.get_carry_in(1), 1);
265          tempvar1 = carryQ.BitBlock_advance_ci_co(tempvar0, carryQ.get_carry_in(2), 2);
266          callouts.delmask = simd_or(callouts.delmask, tempvar1);
267        }
268        else {
269          carryQ.CarryDequeueEnqueue(0, 3);
270        }
271        carryQ.CarryQ_Adjust(3);
272  }
273  IDISA_ALWAYS_INLINE void do_final_block(Lex & lex, Marker & marker, Callouts & callouts, Errors & errors, BitBlock EOF_mask) {
274                BitBlock ref_error;
275
276                BitBlock tempvar0, tempvar1;
277
278
279        marker.Ref_closer = simd<1>::constant<0>();
280        errors.UnterminatedEntityRef = simd<1>::constant<0>();
281        if ((bitblock::any(marker.Ref_opener) || carryQ.CarryTest(0, 3))) {
282          marker.Ref_closer = carryQ.BitBlock_scanthru_ci_co(marker.Ref_opener, simd_or(simd_or(lex.NameScan, marker.Ref_opener), lex.Hash), carryQ.get_carry_in(0), 0);
283          ref_error = simd_andc(marker.Ref_closer, lex.Semicolon);
284          errors.UnterminatedEntityRef = ref_error;
285          tempvar0 = carryQ.BitBlock_span_upto(marker.Ref_opener, marker.Ref_closer, carryQ.get_carry_in(1), 1);
286          tempvar1 = carryQ.BitBlock_advance_ci_co(tempvar0, carryQ.get_carry_in(2), 2);
287          callouts.delmask = simd_or(callouts.delmask, tempvar1);
288        }
289        else {
290          carryQ.CarryDequeueEnqueue(0, 3);
291        }
292  }
293  void do_segment(Lex lex[], Marker marker[], Callouts callouts[], Errors errors[], int segment_blocks) {
294  int i;
295  for (i = 0; i < segment_blocks; i++)
296    do_block(lex[i], marker[i], callouts[i], errors[i]);
297  }
298  CarryArray<3, 0> carryQ;
299  };
300
301  struct Parse_tags {
302  Parse_tags() { 
303 }
304  IDISA_ALWAYS_INLINE void do_block(Lex & lex, Marker & marker, Callouts & callouts, Errors & errors) {
305                BitBlock DQuoteDelim, SQuoteDelim, AttListDelim, ElemName_starts;
306                BitBlock elem_name_follows, NoElemNameErr, AfterWS, AttListEnd, AttNameStart;
307                BitBlock NoAttNameError, AttNameFollow, EqExpected, EqError, AttValPos;
308                BitBlock DQuoteAttVal, SQuoteAttVal, NoAttValErr, DQuoteAttEnd, SQuoteAttEnd;
309                BitBlock AttValEnd, AttValErr, AttValFollow, AttListEndErr, ParseError;
310                BitBlock EndTag_Name_starts, EndTag_Name_follows, EndTagCloseError;
311
312
313
314
315        DQuoteDelim = simd_or(lex.DQuote, lex.LAngle);
316        SQuoteDelim = simd_or(lex.SQuote, lex.LAngle);
317        AttListDelim = simd_or(lex.Slash, lex.RAngle);
318        ElemName_starts = simd_andc(marker.Tag_opener, lex.Slash);
319        callouts.Symbol_starts = simd_or(callouts.Symbol_starts, ElemName_starts);
320        callouts.EndTag_marks = simd_and(marker.Tag_opener, lex.Slash);
321        elem_name_follows = carryQ.BitBlock_scanthru_ci_co(ElemName_starts, lex.NameScan, carryQ.get_carry_in(0), 0);
322        callouts.Symbol_ends = simd_or(callouts.Symbol_ends, elem_name_follows);
323        NoElemNameErr = simd_and(ElemName_starts, elem_name_follows);
324        errors.ExpectedElementName = NoElemNameErr;
325        callouts.AttOpenQuotes = simd<1>::constant<0>();
326        callouts.AttCloseQuotes = simd<1>::constant<0>();
327        callouts.AttEq_marks = simd<1>::constant<0>();
328        errors.ExpectedAttrName = simd<1>::constant<0>();
329        errors.ExpectedEqSign = simd<1>::constant<0>();
330        errors.ExpectedAttrValue = simd<1>::constant<0>();
331        errors.UnterminatedStartTag = simd<1>::constant<0>();
332        errors.ExpectedWhitespace = simd<1>::constant<0>();
333        if ((bitblock::any(simd_and(elem_name_follows, lex.WS)) || carryQ.CarryTest(1, 8))) {
334          AfterWS = carryQ.BitBlock_scanthru_ci_co(elem_name_follows, lex.WS, carryQ.get_carry_in(1), 1);
335          AttListEnd = simd_and(AfterWS, AttListDelim);
336          AttNameStart = simd_andc(AfterWS, AttListDelim);
337          if ((bitblock::any(AttNameStart) || carryQ.CarryTest(2, 7))) {
338            NoAttNameError = simd_or(NoAttNameError, simd_andc(AttNameStart, lex.NameScan));
339            errors.ExpectedAttrName = simd_or(errors.ExpectedAttrName, NoAttNameError);
340            callouts.Symbol_starts = simd_or(callouts.Symbol_starts, AttNameStart);
341            AttNameFollow = carryQ.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, carryQ.get_carry_in(2), 2);
342            callouts.Symbol_ends = simd_or(callouts.Symbol_ends, AttNameFollow);
343            if ((bitblock::any(simd_and(AttNameFollow, lex.WS)) || carryQ.CarryTest(3, 1))) {
344              EqExpected = carryQ.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, carryQ.get_carry_in(3), 3);
345            }
346            else {
347              EqExpected = AttNameFollow;
348              carryQ.CarryDequeueEnqueue(3, 1);
349            }
350            EqError = simd_andc(EqExpected, lex.Equals);
351            errors.ExpectedEqSign = simd_or(errors.ExpectedEqSign, EqError);
352            callouts.AttEq_marks = simd_or(callouts.AttEq_marks, EqExpected);
353            AttValPos = carryQ.BitBlock_scanthru_ci_co(EqExpected, simd_or(EqExpected, lex.WS), carryQ.get_carry_in(4), 4);
354            DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
355            SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
356            NoAttValErr = simd_andc(AttValPos, simd_or(lex.DQuote, lex.SQuote));
357            errors.ExpectedAttrValue = simd_or(errors.ExpectedAttrValue, NoAttValErr);
358            callouts.AttOpenQuotes = simd_or(callouts.AttOpenQuotes, AttValPos);
359            DQuoteAttEnd = carryQ.BitBlock_scanthru_ci_co(DQuoteAttVal, simd_not(simd_andc(DQuoteDelim, DQuoteAttVal)), carryQ.get_carry_in(5), 5);
360            SQuoteAttEnd = carryQ.BitBlock_scanthru_ci_co(SQuoteAttVal, simd_not(simd_andc(SQuoteDelim, SQuoteAttVal)), carryQ.get_carry_in(6), 6);
361            AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
362            AttValErr = simd_andc(AttValEnd, simd_or(lex.DQuote, lex.SQuote));
363            errors.UnterminatedStartTag = simd_or(errors.UnterminatedStartTag, AttValErr);
364            callouts.AttCloseQuotes = simd_or(callouts.AttCloseQuotes, AttValEnd);
365            AttValFollow = carryQ.BitBlock_advance_ci_co(AttValEnd, carryQ.get_carry_in(7), 7);
366            if ((bitblock::any(simd_and(AttValFollow, lex.WS)) || carryQ.CarryTest(8, 1))) {
367              AfterWS = carryQ.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, carryQ.get_carry_in(8), 8);
368            }
369            else {
370              AfterWS = AttValFollow;
371              carryQ.CarryDequeueEnqueue(8, 1);
372            }
373            AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
374            AttNameStart = simd_andc(AfterWS, AttListDelim);
375            AttListEndErr = simd_and(AttValFollow, AttNameStart);
376            errors.ExpectedWhitespace = simd_or(errors.ExpectedWhitespace, AttListEndErr);
377            while (bitblock::any(AttNameStart)) {
378              LocalCarryDeclare(subcarryQ, 7);
379              NoAttNameError = simd_or(NoAttNameError, simd_andc(AttNameStart, lex.NameScan));
380              errors.ExpectedAttrName = simd_or(errors.ExpectedAttrName, NoAttNameError);
381              callouts.Symbol_starts = simd_or(callouts.Symbol_starts, AttNameStart);
382              AttNameFollow = subcarryQ.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, simd<1>::constant<0>(), 0);
383              callouts.Symbol_ends = simd_or(callouts.Symbol_ends, AttNameFollow);
384              if ((bitblock::any(simd_and(AttNameFollow, lex.WS)) || subcarryQ.CarryTest(3, 1))) {
385                EqExpected = subcarryQ.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, simd<1>::constant<0>(), 1);
386              }
387              else {
388                EqExpected = AttNameFollow;
389                subcarryQ.CarryDequeueEnqueue(3, 1);
390              }
391              EqError = simd_andc(EqExpected, lex.Equals);
392              errors.ExpectedEqSign = simd_or(errors.ExpectedEqSign, EqError);
393              callouts.AttEq_marks = simd_or(callouts.AttEq_marks, EqExpected);
394              AttValPos = subcarryQ.BitBlock_scanthru_ci_co(EqExpected, simd_or(EqExpected, lex.WS), simd<1>::constant<0>(), 2);
395              DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
396              SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
397              NoAttValErr = simd_andc(AttValPos, simd_or(lex.DQuote, lex.SQuote));
398              errors.ExpectedAttrValue = simd_or(errors.ExpectedAttrValue, NoAttValErr);
399              callouts.AttOpenQuotes = simd_or(callouts.AttOpenQuotes, AttValPos);
400              DQuoteAttEnd = subcarryQ.BitBlock_scanthru_ci_co(DQuoteAttVal, simd_not(simd_andc(DQuoteDelim, DQuoteAttVal)), simd<1>::constant<0>(), 3);
401              SQuoteAttEnd = subcarryQ.BitBlock_scanthru_ci_co(SQuoteAttVal, simd_not(simd_andc(SQuoteDelim, SQuoteAttVal)), simd<1>::constant<0>(), 4);
402              AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
403              AttValErr = simd_andc(AttValEnd, simd_or(lex.DQuote, lex.SQuote));
404              errors.UnterminatedStartTag = simd_or(errors.UnterminatedStartTag, AttValErr);
405              callouts.AttCloseQuotes = simd_or(callouts.AttCloseQuotes, AttValEnd);
406              AttValFollow = subcarryQ.BitBlock_advance_ci_co(AttValEnd, simd<1>::constant<0>(), 5);
407              if ((bitblock::any(simd_and(AttValFollow, lex.WS)) || subcarryQ.CarryTest(8, 1))) {
408                AfterWS = subcarryQ.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, simd<1>::constant<0>(), 6);
409              }
410              else {
411                AfterWS = AttValFollow;
412                subcarryQ.CarryDequeueEnqueue(8, 1);
413              }
414              AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
415              AttNameStart = simd_andc(AfterWS, AttListDelim);
416              AttListEndErr = simd_and(AttValFollow, AttNameStart);
417              errors.ExpectedWhitespace = simd_or(errors.ExpectedWhitespace, AttListEndErr);
418              carryQ.CarryCombine(subcarryQ.cq, 2, 7);
419            }
420          }
421          else {
422            carryQ.CarryDequeueEnqueue(2, 7);
423          }
424        }
425        else {
426          AttListEnd = simd_and(elem_name_follows, AttListDelim);
427          AttListEndErr = simd_andc(elem_name_follows, AttListDelim);
428          errors.ExpectedWhitespace = simd_or(errors.ExpectedWhitespace, AttListEndErr);
429          carryQ.CarryDequeueEnqueue(1, 8);
430        }
431        callouts.AttValSpan = carryQ.BitBlock_exclusive_span(callouts.AttOpenQuotes, callouts.AttCloseQuotes, carryQ.get_carry_in(9), 9);
432        callouts.StartTag_closers = simd_and(AttListEnd, lex.RAngle);
433        callouts.EmptyTag_marks = simd_and(AttListEnd, lex.Slash);
434        callouts.EmptyTag_closers = carryQ.BitBlock_advance_ci_co(callouts.EmptyTag_marks, carryQ.get_carry_in(10), 10);
435        ParseError = simd_or(ParseError, simd_andc(callouts.EmptyTag_closers, lex.RAngle));
436        errors.UnterminatedStartTag = simd_or(errors.UnterminatedStartTag, ParseError);
437        EndTag_Name_starts = carryQ.BitBlock_advance_ci_co(callouts.EndTag_marks, carryQ.get_carry_in(11), 11);
438        callouts.Symbol_starts = simd_or(callouts.Symbol_starts, EndTag_Name_starts);
439        EndTag_Name_follows = carryQ.BitBlock_scanthru_ci_co(EndTag_Name_starts, lex.NameScan, carryQ.get_carry_in(12), 12);
440        callouts.Symbol_ends = simd_or(callouts.Symbol_ends, EndTag_Name_follows);
441        callouts.EndTag_closers = EndTag_Name_follows;
442        if ((bitblock::any(simd_and(EndTag_Name_follows, lex.WS)) || carryQ.CarryTest(13, 1))) {
443          callouts.EndTag_closers = carryQ.BitBlock_scanthru_ci_co(callouts.EndTag_closers, lex.WS, carryQ.get_carry_in(13), 13);
444        }
445        else {
446          carryQ.CarryDequeueEnqueue(13, 1);
447        }
448        EndTagCloseError = simd_andc(callouts.EndTag_closers, lex.RAngle);
449        errors.UnterminatedEndTag = EndTagCloseError;
450        callouts.Tag_closers = simd_or(simd_or(callouts.StartTag_closers, callouts.EmptyTag_closers), callouts.EndTag_closers);
451        callouts.TagSpan = carryQ.BitBlock_inclusive_span(marker.Tag_opener, callouts.Tag_closers, carryQ.get_carry_in(14), 14);
452        marker.CD_closer = simd_andc(marker.CD_closer, callouts.TagSpan);
453        carryQ.CarryQ_Adjust(15);
454  }
455  IDISA_ALWAYS_INLINE void do_final_block(Lex & lex, Marker & marker, Callouts & callouts, Errors & errors, BitBlock EOF_mask) {
456                BitBlock DQuoteDelim, SQuoteDelim, AttListDelim, ElemName_starts;
457                BitBlock elem_name_follows, NoElemNameErr, AfterWS, AttListEnd, AttNameStart;
458                BitBlock NoAttNameError, AttNameFollow, EqExpected, EqError, AttValPos;
459                BitBlock DQuoteAttVal, SQuoteAttVal, NoAttValErr, DQuoteAttEnd, SQuoteAttEnd;
460                BitBlock AttValEnd, AttValErr, AttValFollow, AttListEndErr, ParseError;
461                BitBlock EndTag_Name_starts, EndTag_Name_follows, EndTagCloseError;
462
463
464
465
466        DQuoteDelim = simd_or(lex.DQuote, lex.LAngle);
467        SQuoteDelim = simd_or(lex.SQuote, lex.LAngle);
468        AttListDelim = simd_or(lex.Slash, lex.RAngle);
469        ElemName_starts = simd_andc(marker.Tag_opener, lex.Slash);
470        callouts.Symbol_starts = simd_or(callouts.Symbol_starts, ElemName_starts);
471        callouts.EndTag_marks = simd_and(marker.Tag_opener, lex.Slash);
472        elem_name_follows = carryQ.BitBlock_scanthru_ci_co(ElemName_starts, lex.NameScan, carryQ.get_carry_in(0), 0);
473        callouts.Symbol_ends = simd_or(callouts.Symbol_ends, elem_name_follows);
474        NoElemNameErr = simd_and(ElemName_starts, elem_name_follows);
475        errors.ExpectedElementName = NoElemNameErr;
476        callouts.AttOpenQuotes = simd<1>::constant<0>();
477        callouts.AttCloseQuotes = simd<1>::constant<0>();
478        callouts.AttEq_marks = simd<1>::constant<0>();
479        errors.ExpectedAttrName = simd<1>::constant<0>();
480        errors.ExpectedEqSign = simd<1>::constant<0>();
481        errors.ExpectedAttrValue = simd<1>::constant<0>();
482        errors.UnterminatedStartTag = simd<1>::constant<0>();
483        errors.ExpectedWhitespace = simd<1>::constant<0>();
484        if ((bitblock::any(simd_and(elem_name_follows, lex.WS)) || carryQ.CarryTest(1, 8))) {
485          AfterWS = carryQ.BitBlock_scanthru_ci_co(elem_name_follows, lex.WS, carryQ.get_carry_in(1), 1);
486          AttListEnd = simd_and(AfterWS, AttListDelim);
487          AttNameStart = simd_andc(AfterWS, AttListDelim);
488          if ((bitblock::any(simd_and(AttNameStart, EOF_mask)) || carryQ.CarryTest(2, 7))) {
489            NoAttNameError = simd_or(NoAttNameError, simd_andc(AttNameStart, lex.NameScan));
490            errors.ExpectedAttrName = simd_or(errors.ExpectedAttrName, NoAttNameError);
491            callouts.Symbol_starts = simd_or(callouts.Symbol_starts, AttNameStart);
492            AttNameFollow = carryQ.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, carryQ.get_carry_in(2), 2);
493            callouts.Symbol_ends = simd_or(callouts.Symbol_ends, AttNameFollow);
494            if ((bitblock::any(simd_and(AttNameFollow, lex.WS)) || carryQ.CarryTest(3, 1))) {
495              EqExpected = carryQ.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, carryQ.get_carry_in(3), 3);
496            }
497            else {
498              EqExpected = AttNameFollow;
499              carryQ.CarryDequeueEnqueue(3, 1);
500            }
501            EqError = simd_andc(EqExpected, lex.Equals);
502            errors.ExpectedEqSign = simd_or(errors.ExpectedEqSign, EqError);
503            callouts.AttEq_marks = simd_or(callouts.AttEq_marks, EqExpected);
504            AttValPos = carryQ.BitBlock_scanthru_ci_co(EqExpected, simd_or(EqExpected, lex.WS), carryQ.get_carry_in(4), 4);
505            DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
506            SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
507            NoAttValErr = simd_andc(AttValPos, simd_or(lex.DQuote, lex.SQuote));
508            errors.ExpectedAttrValue = simd_or(errors.ExpectedAttrValue, NoAttValErr);
509            callouts.AttOpenQuotes = simd_or(callouts.AttOpenQuotes, AttValPos);
510            DQuoteAttEnd = carryQ.BitBlock_scanthru_ci_co(DQuoteAttVal, simd_andc(EOF_mask, simd_andc(DQuoteDelim, DQuoteAttVal)), carryQ.get_carry_in(5), 5);
511            SQuoteAttEnd = carryQ.BitBlock_scanthru_ci_co(SQuoteAttVal, simd_andc(EOF_mask, simd_andc(SQuoteDelim, SQuoteAttVal)), carryQ.get_carry_in(6), 6);
512            AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
513            AttValErr = simd_andc(AttValEnd, simd_or(lex.DQuote, lex.SQuote));
514            errors.UnterminatedStartTag = simd_or(errors.UnterminatedStartTag, AttValErr);
515            callouts.AttCloseQuotes = simd_or(callouts.AttCloseQuotes, AttValEnd);
516            AttValFollow = carryQ.BitBlock_advance_ci_co(AttValEnd, carryQ.get_carry_in(7), 7);
517            if ((bitblock::any(simd_and(AttValFollow, lex.WS)) || carryQ.CarryTest(8, 1))) {
518              AfterWS = carryQ.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, carryQ.get_carry_in(8), 8);
519            }
520            else {
521              AfterWS = AttValFollow;
522              carryQ.CarryDequeueEnqueue(8, 1);
523            }
524            AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
525            AttNameStart = simd_andc(AfterWS, AttListDelim);
526            AttListEndErr = simd_and(AttValFollow, AttNameStart);
527            errors.ExpectedWhitespace = simd_or(errors.ExpectedWhitespace, AttListEndErr);
528            while (bitblock::any(simd_and(AttNameStart, EOF_mask))) {
529              LocalCarryDeclare(subcarryQ, 7);
530              NoAttNameError = simd_or(NoAttNameError, simd_andc(AttNameStart, lex.NameScan));
531              errors.ExpectedAttrName = simd_or(errors.ExpectedAttrName, NoAttNameError);
532              callouts.Symbol_starts = simd_or(callouts.Symbol_starts, AttNameStart);
533              AttNameFollow = subcarryQ.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, simd<1>::constant<0>(), 0);
534              callouts.Symbol_ends = simd_or(callouts.Symbol_ends, AttNameFollow);
535              if ((bitblock::any(simd_and(AttNameFollow, lex.WS)) || subcarryQ.CarryTest(3, 1))) {
536                EqExpected = subcarryQ.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, simd<1>::constant<0>(), 1);
537              }
538              else {
539                EqExpected = AttNameFollow;
540                subcarryQ.CarryDequeueEnqueue(3, 1);
541              }
542              EqError = simd_andc(EqExpected, lex.Equals);
543              errors.ExpectedEqSign = simd_or(errors.ExpectedEqSign, EqError);
544              callouts.AttEq_marks = simd_or(callouts.AttEq_marks, EqExpected);
545              AttValPos = subcarryQ.BitBlock_scanthru_ci_co(EqExpected, simd_or(EqExpected, lex.WS), simd<1>::constant<0>(), 2);
546              DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
547              SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
548              NoAttValErr = simd_andc(AttValPos, simd_or(lex.DQuote, lex.SQuote));
549              errors.ExpectedAttrValue = simd_or(errors.ExpectedAttrValue, NoAttValErr);
550              callouts.AttOpenQuotes = simd_or(callouts.AttOpenQuotes, AttValPos);
551              DQuoteAttEnd = subcarryQ.BitBlock_scanthru_ci_co(DQuoteAttVal, simd_andc(EOF_mask, simd_andc(DQuoteDelim, DQuoteAttVal)), simd<1>::constant<0>(), 3);
552              SQuoteAttEnd = subcarryQ.BitBlock_scanthru_ci_co(SQuoteAttVal, simd_andc(EOF_mask, simd_andc(SQuoteDelim, SQuoteAttVal)), simd<1>::constant<0>(), 4);
553              AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
554              AttValErr = simd_andc(AttValEnd, simd_or(lex.DQuote, lex.SQuote));
555              errors.UnterminatedStartTag = simd_or(errors.UnterminatedStartTag, AttValErr);
556              callouts.AttCloseQuotes = simd_or(callouts.AttCloseQuotes, AttValEnd);
557              AttValFollow = subcarryQ.BitBlock_advance_ci_co(AttValEnd, simd<1>::constant<0>(), 5);
558              if ((bitblock::any(simd_and(AttValFollow, lex.WS)) || subcarryQ.CarryTest(8, 1))) {
559                AfterWS = subcarryQ.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, simd<1>::constant<0>(), 6);
560              }
561              else {
562                AfterWS = AttValFollow;
563                subcarryQ.CarryDequeueEnqueue(8, 1);
564              }
565              AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
566              AttNameStart = simd_andc(AfterWS, AttListDelim);
567              AttListEndErr = simd_and(AttValFollow, AttNameStart);
568              errors.ExpectedWhitespace = simd_or(errors.ExpectedWhitespace, AttListEndErr);
569              carryQ.CarryCombine(subcarryQ.cq, 2, 7);
570            }
571          }
572          else {
573            carryQ.CarryDequeueEnqueue(2, 7);
574          }
575        }
576        else {
577          AttListEnd = simd_and(elem_name_follows, AttListDelim);
578          AttListEndErr = simd_andc(elem_name_follows, AttListDelim);
579          errors.ExpectedWhitespace = simd_or(errors.ExpectedWhitespace, AttListEndErr);
580          carryQ.CarryDequeueEnqueue(1, 8);
581        }
582        callouts.AttValSpan = carryQ.BitBlock_exclusive_span(callouts.AttOpenQuotes, callouts.AttCloseQuotes, carryQ.get_carry_in(9), 9);
583        callouts.StartTag_closers = simd_and(AttListEnd, lex.RAngle);
584        callouts.EmptyTag_marks = simd_and(AttListEnd, lex.Slash);
585        callouts.EmptyTag_closers = carryQ.BitBlock_advance_ci_co(callouts.EmptyTag_marks, carryQ.get_carry_in(10), 10);
586        ParseError = simd_or(ParseError, simd_andc(callouts.EmptyTag_closers, lex.RAngle));
587        errors.UnterminatedStartTag = simd_or(errors.UnterminatedStartTag, ParseError);
588        EndTag_Name_starts = carryQ.BitBlock_advance_ci_co(callouts.EndTag_marks, carryQ.get_carry_in(11), 11);
589        callouts.Symbol_starts = simd_or(callouts.Symbol_starts, EndTag_Name_starts);
590        EndTag_Name_follows = carryQ.BitBlock_scanthru_ci_co(EndTag_Name_starts, lex.NameScan, carryQ.get_carry_in(12), 12);
591        callouts.Symbol_ends = simd_or(callouts.Symbol_ends, EndTag_Name_follows);
592        callouts.EndTag_closers = EndTag_Name_follows;
593        if ((bitblock::any(simd_and(EndTag_Name_follows, lex.WS)) || carryQ.CarryTest(13, 1))) {
594          callouts.EndTag_closers = carryQ.BitBlock_scanthru_ci_co(callouts.EndTag_closers, lex.WS, carryQ.get_carry_in(13), 13);
595        }
596        else {
597          carryQ.CarryDequeueEnqueue(13, 1);
598        }
599        EndTagCloseError = simd_andc(callouts.EndTag_closers, lex.RAngle);
600        errors.UnterminatedEndTag = EndTagCloseError;
601        callouts.Tag_closers = simd_or(simd_or(callouts.StartTag_closers, callouts.EmptyTag_closers), callouts.EndTag_closers);
602        callouts.TagSpan = carryQ.BitBlock_inclusive_span(marker.Tag_opener, callouts.Tag_closers, carryQ.get_carry_in(14), 14);
603        marker.CD_closer = simd_andc(marker.CD_closer, callouts.TagSpan);
604  }
605  void do_segment(Lex lex[], Marker marker[], Callouts callouts[], Errors errors[], int segment_blocks) {
606  int i;
607  for (i = 0; i < segment_blocks; i++)
608    do_block(lex[i], marker[i], callouts[i], errors[i]);
609  }
610  CarryArray<15, 0> carryQ;
611  };
612
613  struct Init_Parameters {
614 
615  IDISA_ALWAYS_INLINE void do_block(Parameters & parameters) {
616
617
618
619
620
621        parameters.XML_11 = simd<1>::constant<0>();
622  }
623  IDISA_ALWAYS_INLINE void do_final_block(Parameters & parameters, BitBlock EOF_mask) {
624
625
626
627
628
629        parameters.XML_11 = simd<1>::constant<0>();
630  }
631  void do_segment(Parameters parameters[], int segment_blocks) {
632  int i;
633  for (i = 0; i < segment_blocks; i++)
634    do_block(parameters[i]);
635  }
636 
637  };
638
639  struct Parse_CtCDPI {
640  Parse_CtCDPI() { 
641carryQ.cq[4] = carryQ.carry_flip(carryQ.cq[4]);
642 }
643  IDISA_ALWAYS_INLINE void do_block(Lex & lex, Marker & marker, Callouts & callouts, Errors & errors) {
644                BitBlock CtCDPI_starts, v, w, v1, w1, LAngle_scope, PI_opener, CtCD_opener;
645                BitBlock CtCDPI_opener, CD_closer, DoubleHyphen, DoubleRBracket, PI_closer;
646                BitBlock CtCDPI_Cursor, PI_Cursor, CD_Ct_Cursor, CD_Cursor, Ct_Cursor;
647                BitBlock CD_Ct_Error, PI_name_end, PI_error, Ct_error;
648
649                BitBlock tempvar0, tempvar1, tempvar2, tempvar3, tempvar4, tempvar5;
650
651
652        callouts.Symbol_starts = simd<1>::constant<0>();
653        callouts.Symbol_ends = simd<1>::constant<0>();
654        callouts.CtCDPI_marks = simd<1>::constant<0>();
655        callouts.CtCDPI_content_starts = simd<1>::constant<0>();
656        callouts.CtCDPI_closers = simd<1>::constant<0>();
657        callouts.delmask = simd<1>::constant<0>();
658        callouts.ctCDPI_mask = simd<1>::constant<0>();
659        errors.ExpectedCommentOrCDATA = simd<1>::constant<0>();
660        errors.PINameExpected = simd<1>::constant<0>();
661        errors.IllegalSequenceInComment = simd<1>::constant<0>();
662        errors.UnterminatedPI = simd<1>::constant<0>();
663        errors.UnterminatedCDATASection = simd<1>::constant<0>();
664        errors.UnterminatedComment = simd<1>::constant<0>();
665        CtCDPI_starts = simd<1>::constant<0>();
666        v = simd_or(lex.LAngle, lex.Hyphen);
667        w = simd_or(lex.Hyphen, lex.QMark);
668        v1 = carryQ.BitBlock_advance_ci_co(v, carryQ.get_carry_in(0), 0);
669        w1 = carryQ.BitBlock_advance_ci_co(w, carryQ.get_carry_in(1), 1);
670        LAngle_scope = simd_andc(v1, w1);
671        PI_opener = simd_and(LAngle_scope, lex.QMark);
672        CtCD_opener = simd_and(LAngle_scope, lex.Exclam);
673        CtCDPI_opener = simd_or(PI_opener, CtCD_opener);
674        CD_closer = simd<1>::constant<0>();
675        DoubleHyphen = simd_and(simd_and(v1, w1), lex.Hyphen);
676        if ((bitblock::any(lex.RBracket) || carryQ.CarryTest(2, 2))) {
677          tempvar0 = carryQ.BitBlock_advance_ci_co(lex.RBracket, carryQ.get_carry_in(2), 2);
678          DoubleRBracket = simd_and(tempvar0, lex.RBracket);
679          tempvar1 = carryQ.BitBlock_advance_ci_co(DoubleRBracket, carryQ.get_carry_in(3), 3);
680          CD_closer = simd_and(tempvar1, lex.RAngle);
681        }
682        else {
683          carryQ.CarryDequeueEnqueue(2, 2);
684        }
685        PI_closer = simd_and(simd_andc(w1, v1), lex.RAngle);
686        CtCDPI_Cursor = carryQ.BitBlock_scantofirst(CtCDPI_opener, carryQ.get_carry_in(4), 4);
687        if ((bitblock::any(CtCDPI_Cursor) || carryQ.CarryTest(5, 14))) {
688          CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
689          PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
690          CD_Ct_Cursor = carryQ.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), carryQ.get_carry_in(5), 5);
691          callouts.CtCDPI_marks = simd_or(callouts.CtCDPI_marks, simd_or(PI_Cursor, CD_Ct_Cursor));
692          CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
693          Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
694          CD_Ct_Error = simd_andc(CD_Ct_Cursor, simd_or(lex.LBracket, lex.Hyphen));
695          errors.ExpectedCommentOrCDATA = simd_or(errors.ExpectedCommentOrCDATA, CD_Ct_Error);
696          if ((bitblock::any(PI_Cursor) || carryQ.CarryTest(6, 5))) {
697            callouts.Symbol_starts = simd_or(callouts.Symbol_starts, PI_Cursor);
698            PI_Cursor = carryQ.BitBlock_advance_ci_co(PI_Cursor, carryQ.get_carry_in(6), 6);
699            PI_name_end = carryQ.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, carryQ.get_carry_in(7), 7);
700            PI_error = simd_and(PI_Cursor, PI_name_end);
701            errors.PINameExpected = simd_or(errors.PINameExpected, PI_error);
702            tempvar2 = carryQ.BitBlock_advance_ci_co(simd_andc(PI_name_end, lex.WS), carryQ.get_carry_in(8), 8);
703            PI_error = simd_andc(tempvar2, PI_closer);
704            errors.UnterminatedPI = simd_or(errors.UnterminatedPI, PI_error);
705            callouts.Symbol_ends = simd_or(callouts.Symbol_ends, PI_name_end);
706            tempvar3 = carryQ.BitBlock_scanthru_ci_co(PI_name_end, lex.WS, carryQ.get_carry_in(9), 9);
707            callouts.CtCDPI_content_starts = simd_or(callouts.CtCDPI_content_starts, tempvar3);
708            PI_Cursor = carryQ.BitBlock_scanthru_ci_co(PI_name_end, simd_not(PI_closer), carryQ.get_carry_in(10), 10);
709          }
710          else {
711            carryQ.CarryDequeueEnqueue(6, 5);
712          }
713          if ((bitblock::any(CD_Cursor) || carryQ.CarryTest(11, 1))) {
714            callouts.CtCDPI_content_starts = simd_or(callouts.CtCDPI_content_starts, CD_Cursor);
715            CD_Cursor = carryQ.BitBlock_scanthru_ci_co(CD_Cursor, simd_not(CD_closer), carryQ.get_carry_in(11), 11);
716          }
717          else {
718            carryQ.CarryDequeueEnqueue(11, 1);
719          }
720          if ((bitblock::any(Ct_Cursor) || carryQ.CarryTest(12, 5))) {
721            Ct_Cursor = carryQ.BitBlock_advance_ci_co(Ct_Cursor, carryQ.get_carry_in(12), 12);
722            Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
723            Ct_Cursor = carryQ.BitBlock_advance_ci_co(Ct_Cursor, carryQ.get_carry_in(13), 13);
724            callouts.CtCDPI_content_starts = simd_or(callouts.CtCDPI_content_starts, Ct_Cursor);
725            Ct_Cursor = carryQ.BitBlock_advance_ci_co(Ct_Cursor, carryQ.get_carry_in(14), 14);
726            tempvar4 = carryQ.BitBlock_scanthru_ci_co(Ct_Cursor, simd_not(DoubleHyphen), carryQ.get_carry_in(15), 15);
727            Ct_Cursor = carryQ.BitBlock_advance_ci_co(tempvar4, carryQ.get_carry_in(16), 16);
728            Ct_error = simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle));
729            errors.IllegalSequenceInComment = simd_or(errors.IllegalSequenceInComment, Ct_error);
730          }
731          else {
732            carryQ.CarryDequeueEnqueue(12, 5);
733          }
734          CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
735          callouts.CtCDPI_closers = simd_or(callouts.CtCDPI_closers, CtCDPI_Cursor);
736          tempvar5 = carryQ.BitBlock_inclusive_span(CtCDPI_starts, callouts.CtCDPI_closers, carryQ.get_carry_in(17), 17);
737          callouts.ctCDPI_mask = simd_or(callouts.ctCDPI_mask, tempvar5);
738          if (bitblock::any(simd<1>::constant<0>())) {
739            if (bitblock::any(simd<1>::constant<0>())) {
740              errors.UnterminatedPI = simd_or(errors.UnterminatedPI, PI_Cursor);
741            }
742            if (bitblock::any(simd<1>::constant<0>())) {
743              errors.UnterminatedCDATASection = simd_or(errors.UnterminatedCDATASection, CD_Cursor);
744            }
745            if (bitblock::any(simd<1>::constant<0>())) {
746              errors.UnterminatedComment = simd_or(errors.UnterminatedComment, Ct_Cursor);
747            }
748          }
749          CtCDPI_Cursor = carryQ.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_not(CtCDPI_opener), carryQ.get_carry_in(18), 18);
750          while (bitblock::any(CtCDPI_Cursor)) {
751            LocalCarryDeclare(subcarryQ, 14);
752            CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
753            PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
754            CD_Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), simd<1>::constant<0>(), 0);
755            callouts.CtCDPI_marks = simd_or(callouts.CtCDPI_marks, simd_or(PI_Cursor, CD_Ct_Cursor));
756            CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
757            Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
758            CD_Ct_Error = simd_andc(CD_Ct_Cursor, simd_or(lex.LBracket, lex.Hyphen));
759            errors.ExpectedCommentOrCDATA = simd_or(errors.ExpectedCommentOrCDATA, CD_Ct_Error);
760            if ((bitblock::any(PI_Cursor) || subcarryQ.CarryTest(6, 5))) {
761              callouts.Symbol_starts = simd_or(callouts.Symbol_starts, PI_Cursor);
762              PI_Cursor = subcarryQ.BitBlock_advance_ci_co(PI_Cursor, simd<1>::constant<0>(), 1);
763              PI_name_end = subcarryQ.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, simd<1>::constant<0>(), 2);
764              PI_error = simd_and(PI_Cursor, PI_name_end);
765              errors.PINameExpected = simd_or(errors.PINameExpected, PI_error);
766              tempvar2 = subcarryQ.BitBlock_advance_ci_co(simd_andc(PI_name_end, lex.WS), simd<1>::constant<0>(), 3);
767              PI_error = simd_andc(tempvar2, PI_closer);
768              errors.UnterminatedPI = simd_or(errors.UnterminatedPI, PI_error);
769              callouts.Symbol_ends = simd_or(callouts.Symbol_ends, PI_name_end);
770              tempvar3 = subcarryQ.BitBlock_scanthru_ci_co(PI_name_end, lex.WS, simd<1>::constant<0>(), 4);
771              callouts.CtCDPI_content_starts = simd_or(callouts.CtCDPI_content_starts, tempvar3);
772              PI_Cursor = subcarryQ.BitBlock_scanthru_ci_co(PI_name_end, simd_not(PI_closer), simd<1>::constant<0>(), 5);
773            }
774            else {
775              subcarryQ.CarryDequeueEnqueue(6, 5);
776            }
777            if ((bitblock::any(CD_Cursor) || subcarryQ.CarryTest(11, 1))) {
778              callouts.CtCDPI_content_starts = simd_or(callouts.CtCDPI_content_starts, CD_Cursor);
779              CD_Cursor = subcarryQ.BitBlock_scanthru_ci_co(CD_Cursor, simd_not(CD_closer), simd<1>::constant<0>(), 6);
780            }
781            else {
782              subcarryQ.CarryDequeueEnqueue(11, 1);
783            }
784            if ((bitblock::any(Ct_Cursor) || subcarryQ.CarryTest(12, 5))) {
785              Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 7);
786              Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
787              Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 8);
788              callouts.CtCDPI_content_starts = simd_or(callouts.CtCDPI_content_starts, Ct_Cursor);
789              Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 9);
790              tempvar4 = subcarryQ.BitBlock_scanthru_ci_co(Ct_Cursor, simd_not(DoubleHyphen), simd<1>::constant<0>(), 10);
791              Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(tempvar4, simd<1>::constant<0>(), 11);
792              Ct_error = simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle));
793              errors.IllegalSequenceInComment = simd_or(errors.IllegalSequenceInComment, Ct_error);
794            }
795            else {
796              subcarryQ.CarryDequeueEnqueue(12, 5);
797            }
798            CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
799            callouts.CtCDPI_closers = simd_or(callouts.CtCDPI_closers, CtCDPI_Cursor);
800            tempvar5 = subcarryQ.BitBlock_inclusive_span(CtCDPI_starts, callouts.CtCDPI_closers, simd<1>::constant<0>(), 12);
801            callouts.ctCDPI_mask = simd_or(callouts.ctCDPI_mask, tempvar5);
802            if (bitblock::any(simd<1>::constant<0>())) {
803              if (bitblock::any(simd<1>::constant<0>())) {
804                errors.UnterminatedPI = simd_or(errors.UnterminatedPI, PI_Cursor);
805              }
806              if (bitblock::any(simd<1>::constant<0>())) {
807                errors.UnterminatedCDATASection = simd_or(errors.UnterminatedCDATASection, CD_Cursor);
808              }
809              if (bitblock::any(simd<1>::constant<0>())) {
810                errors.UnterminatedComment = simd_or(errors.UnterminatedComment, Ct_Cursor);
811              }
812            }
813            CtCDPI_Cursor = subcarryQ.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_not(CtCDPI_opener), simd<1>::constant<0>(), 13);
814            carryQ.CarryCombine(subcarryQ.cq, 5, 14);
815          }
816          carryQ.CarryCombine1(4, 18);
817        }
818        else {
819          carryQ.CarryDequeueEnqueue(5, 14);
820        }
821        marker.LAngle = simd_andc(lex.LAngle, callouts.ctCDPI_mask);
822        marker.Tag_opener = simd_andc(LAngle_scope, callouts.ctCDPI_mask);
823        marker.Ref_opener = simd_andc(lex.RefStart, callouts.ctCDPI_mask);
824        marker.CD_closer = simd_andc(CD_closer, callouts.ctCDPI_mask);
825        carryQ.CarryQ_Adjust(19);
826  }
827  IDISA_ALWAYS_INLINE void do_final_block(Lex & lex, Marker & marker, Callouts & callouts, Errors & errors, BitBlock EOF_mask) {
828                BitBlock CtCDPI_starts, v, w, v1, w1, LAngle_scope, PI_opener, CtCD_opener;
829                BitBlock CtCDPI_opener, CD_closer, DoubleHyphen, DoubleRBracket, PI_closer;
830                BitBlock CtCDPI_Cursor, PI_Cursor, CD_Ct_Cursor, CD_Cursor, Ct_Cursor;
831                BitBlock CD_Ct_Error, PI_name_end, PI_error, Ct_error;
832
833                BitBlock tempvar0, tempvar1, tempvar2, tempvar3, tempvar4, tempvar5;
834
835
836        callouts.Symbol_starts = simd<1>::constant<0>();
837        callouts.Symbol_ends = simd<1>::constant<0>();
838        callouts.CtCDPI_marks = simd<1>::constant<0>();
839        callouts.CtCDPI_content_starts = simd<1>::constant<0>();
840        callouts.CtCDPI_closers = simd<1>::constant<0>();
841        callouts.delmask = simd<1>::constant<0>();
842        callouts.ctCDPI_mask = simd<1>::constant<0>();
843        errors.ExpectedCommentOrCDATA = simd<1>::constant<0>();
844        errors.PINameExpected = simd<1>::constant<0>();
845        errors.IllegalSequenceInComment = simd<1>::constant<0>();
846        errors.UnterminatedPI = simd<1>::constant<0>();
847        errors.UnterminatedCDATASection = simd<1>::constant<0>();
848        errors.UnterminatedComment = simd<1>::constant<0>();
849        CtCDPI_starts = simd<1>::constant<0>();
850        v = simd_or(lex.LAngle, lex.Hyphen);
851        w = simd_or(lex.Hyphen, lex.QMark);
852        v1 = carryQ.BitBlock_advance_ci_co(v, carryQ.get_carry_in(0), 0);
853        w1 = carryQ.BitBlock_advance_ci_co(w, carryQ.get_carry_in(1), 1);
854        LAngle_scope = simd_andc(v1, w1);
855        PI_opener = simd_and(LAngle_scope, lex.QMark);
856        CtCD_opener = simd_and(LAngle_scope, lex.Exclam);
857        CtCDPI_opener = simd_or(PI_opener, CtCD_opener);
858        CD_closer = simd<1>::constant<0>();
859        DoubleHyphen = simd_and(simd_and(v1, w1), lex.Hyphen);
860        if ((bitblock::any(lex.RBracket) || carryQ.CarryTest(2, 2))) {
861          tempvar0 = carryQ.BitBlock_advance_ci_co(lex.RBracket, carryQ.get_carry_in(2), 2);
862          DoubleRBracket = simd_and(tempvar0, lex.RBracket);
863          tempvar1 = carryQ.BitBlock_advance_ci_co(DoubleRBracket, carryQ.get_carry_in(3), 3);
864          CD_closer = simd_and(tempvar1, lex.RAngle);
865        }
866        else {
867          carryQ.CarryDequeueEnqueue(2, 2);
868        }
869        PI_closer = simd_and(simd_andc(w1, v1), lex.RAngle);
870        CtCDPI_Cursor = carryQ.BitBlock_scantofirst(CtCDPI_opener, carryQ.get_carry_in(4), 4);
871        if ((bitblock::any(simd_and(CtCDPI_Cursor, EOF_mask)) || carryQ.CarryTest(5, 14))) {
872          CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
873          PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
874          CD_Ct_Cursor = carryQ.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), carryQ.get_carry_in(5), 5);
875          callouts.CtCDPI_marks = simd_or(callouts.CtCDPI_marks, simd_or(PI_Cursor, CD_Ct_Cursor));
876          CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
877          Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
878          CD_Ct_Error = simd_andc(CD_Ct_Cursor, simd_or(lex.LBracket, lex.Hyphen));
879          errors.ExpectedCommentOrCDATA = simd_or(errors.ExpectedCommentOrCDATA, CD_Ct_Error);
880          if ((bitblock::any(PI_Cursor) || carryQ.CarryTest(6, 5))) {
881            callouts.Symbol_starts = simd_or(callouts.Symbol_starts, PI_Cursor);
882            PI_Cursor = carryQ.BitBlock_advance_ci_co(PI_Cursor, carryQ.get_carry_in(6), 6);
883            PI_name_end = carryQ.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, carryQ.get_carry_in(7), 7);
884            PI_error = simd_and(PI_Cursor, PI_name_end);
885            errors.PINameExpected = simd_or(errors.PINameExpected, PI_error);
886            tempvar2 = carryQ.BitBlock_advance_ci_co(simd_andc(PI_name_end, lex.WS), carryQ.get_carry_in(8), 8);
887            PI_error = simd_andc(tempvar2, PI_closer);
888            errors.UnterminatedPI = simd_or(errors.UnterminatedPI, PI_error);
889            callouts.Symbol_ends = simd_or(callouts.Symbol_ends, PI_name_end);
890            tempvar3 = carryQ.BitBlock_scanthru_ci_co(PI_name_end, lex.WS, carryQ.get_carry_in(9), 9);
891            callouts.CtCDPI_content_starts = simd_or(callouts.CtCDPI_content_starts, tempvar3);
892            PI_Cursor = carryQ.BitBlock_scanthru_ci_co(PI_name_end, simd_andc(EOF_mask, PI_closer), carryQ.get_carry_in(10), 10);
893          }
894          else {
895            carryQ.CarryDequeueEnqueue(6, 5);
896          }
897          if ((bitblock::any(CD_Cursor) || carryQ.CarryTest(11, 1))) {
898            callouts.CtCDPI_content_starts = simd_or(callouts.CtCDPI_content_starts, CD_Cursor);
899            CD_Cursor = carryQ.BitBlock_scanthru_ci_co(CD_Cursor, simd_andc(EOF_mask, CD_closer), carryQ.get_carry_in(11), 11);
900          }
901          else {
902            carryQ.CarryDequeueEnqueue(11, 1);
903          }
904          if ((bitblock::any(Ct_Cursor) || carryQ.CarryTest(12, 5))) {
905            Ct_Cursor = carryQ.BitBlock_advance_ci_co(Ct_Cursor, carryQ.get_carry_in(12), 12);
906            Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
907            Ct_Cursor = carryQ.BitBlock_advance_ci_co(Ct_Cursor, carryQ.get_carry_in(13), 13);
908            callouts.CtCDPI_content_starts = simd_or(callouts.CtCDPI_content_starts, Ct_Cursor);
909            Ct_Cursor = carryQ.BitBlock_advance_ci_co(Ct_Cursor, carryQ.get_carry_in(14), 14);
910            tempvar4 = carryQ.BitBlock_scanthru_ci_co(Ct_Cursor, simd_andc(EOF_mask, DoubleHyphen), carryQ.get_carry_in(15), 15);
911            Ct_Cursor = carryQ.BitBlock_advance_ci_co(tempvar4, carryQ.get_carry_in(16), 16);
912            Ct_error = simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle));
913            errors.IllegalSequenceInComment = simd_or(errors.IllegalSequenceInComment, Ct_error);
914          }
915          else {
916            carryQ.CarryDequeueEnqueue(12, 5);
917          }
918          CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
919          callouts.CtCDPI_closers = simd_or(callouts.CtCDPI_closers, CtCDPI_Cursor);
920          tempvar5 = carryQ.BitBlock_inclusive_span(CtCDPI_starts, callouts.CtCDPI_closers, carryQ.get_carry_in(17), 17);
921          callouts.ctCDPI_mask = simd_or(callouts.ctCDPI_mask, tempvar5);
922          if (bitblock::any(simd_andc(callouts.ctCDPI_mask, EOF_mask))) {
923            if (bitblock::any(simd_andc(PI_Cursor, EOF_mask))) {
924              errors.UnterminatedPI = simd_or(errors.UnterminatedPI, PI_Cursor);
925            }
926            if (bitblock::any(simd_andc(CD_Cursor, EOF_mask))) {
927              errors.UnterminatedCDATASection = simd_or(errors.UnterminatedCDATASection, CD_Cursor);
928            }
929            if (bitblock::any(simd_andc(Ct_Cursor, EOF_mask))) {
930              errors.UnterminatedComment = simd_or(errors.UnterminatedComment, Ct_Cursor);
931            }
932          }
933          CtCDPI_Cursor = carryQ.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), carryQ.get_carry_in(18), 18);
934          while (bitblock::any(simd_and(CtCDPI_Cursor, EOF_mask))) {
935            LocalCarryDeclare(subcarryQ, 14);
936            CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
937            PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
938            CD_Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), simd<1>::constant<0>(), 0);
939            callouts.CtCDPI_marks = simd_or(callouts.CtCDPI_marks, simd_or(PI_Cursor, CD_Ct_Cursor));
940            CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
941            Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
942            CD_Ct_Error = simd_andc(CD_Ct_Cursor, simd_or(lex.LBracket, lex.Hyphen));
943            errors.ExpectedCommentOrCDATA = simd_or(errors.ExpectedCommentOrCDATA, CD_Ct_Error);
944            if ((bitblock::any(PI_Cursor) || subcarryQ.CarryTest(6, 5))) {
945              callouts.Symbol_starts = simd_or(callouts.Symbol_starts, PI_Cursor);
946              PI_Cursor = subcarryQ.BitBlock_advance_ci_co(PI_Cursor, simd<1>::constant<0>(), 1);
947              PI_name_end = subcarryQ.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, simd<1>::constant<0>(), 2);
948              PI_error = simd_and(PI_Cursor, PI_name_end);
949              errors.PINameExpected = simd_or(errors.PINameExpected, PI_error);
950              tempvar2 = subcarryQ.BitBlock_advance_ci_co(simd_andc(PI_name_end, lex.WS), simd<1>::constant<0>(), 3);
951              PI_error = simd_andc(tempvar2, PI_closer);
952              errors.UnterminatedPI = simd_or(errors.UnterminatedPI, PI_error);
953              callouts.Symbol_ends = simd_or(callouts.Symbol_ends, PI_name_end);
954              tempvar3 = subcarryQ.BitBlock_scanthru_ci_co(PI_name_end, lex.WS, simd<1>::constant<0>(), 4);
955              callouts.CtCDPI_content_starts = simd_or(callouts.CtCDPI_content_starts, tempvar3);
956              PI_Cursor = subcarryQ.BitBlock_scanthru_ci_co(PI_name_end, simd_andc(EOF_mask, PI_closer), simd<1>::constant<0>(), 5);
957            }
958            else {
959              subcarryQ.CarryDequeueEnqueue(6, 5);
960            }
961            if ((bitblock::any(CD_Cursor) || subcarryQ.CarryTest(11, 1))) {
962              callouts.CtCDPI_content_starts = simd_or(callouts.CtCDPI_content_starts, CD_Cursor);
963              CD_Cursor = subcarryQ.BitBlock_scanthru_ci_co(CD_Cursor, simd_andc(EOF_mask, CD_closer), simd<1>::constant<0>(), 6);
964            }
965            else {
966              subcarryQ.CarryDequeueEnqueue(11, 1);
967            }
968            if ((bitblock::any(Ct_Cursor) || subcarryQ.CarryTest(12, 5))) {
969              Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 7);
970              Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
971              Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 8);
972              callouts.CtCDPI_content_starts = simd_or(callouts.CtCDPI_content_starts, Ct_Cursor);
973              Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 9);
974              tempvar4 = subcarryQ.BitBlock_scanthru_ci_co(Ct_Cursor, simd_andc(EOF_mask, DoubleHyphen), simd<1>::constant<0>(), 10);
975              Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(tempvar4, simd<1>::constant<0>(), 11);
976              Ct_error = simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle));
977              errors.IllegalSequenceInComment = simd_or(errors.IllegalSequenceInComment, Ct_error);
978            }
979            else {
980              subcarryQ.CarryDequeueEnqueue(12, 5);
981            }
982            CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
983            callouts.CtCDPI_closers = simd_or(callouts.CtCDPI_closers, CtCDPI_Cursor);
984            tempvar5 = subcarryQ.BitBlock_inclusive_span(CtCDPI_starts, callouts.CtCDPI_closers, simd<1>::constant<0>(), 12);
985            callouts.ctCDPI_mask = simd_or(callouts.ctCDPI_mask, tempvar5);
986            if (bitblock::any(simd_andc(callouts.ctCDPI_mask, EOF_mask))) {
987              if (bitblock::any(simd_andc(PI_Cursor, EOF_mask))) {
988                errors.UnterminatedPI = simd_or(errors.UnterminatedPI, PI_Cursor);
989              }
990              if (bitblock::any(simd_andc(CD_Cursor, EOF_mask))) {
991                errors.UnterminatedCDATASection = simd_or(errors.UnterminatedCDATASection, CD_Cursor);
992              }
993              if (bitblock::any(simd_andc(Ct_Cursor, EOF_mask))) {
994                errors.UnterminatedComment = simd_or(errors.UnterminatedComment, Ct_Cursor);
995              }
996            }
997            CtCDPI_Cursor = subcarryQ.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), simd<1>::constant<0>(), 13);
998            carryQ.CarryCombine(subcarryQ.cq, 5, 14);
999          }
1000        }
1001        else {
1002          carryQ.CarryDequeueEnqueue(5, 14);
1003        }
1004        marker.LAngle = simd_andc(lex.LAngle, callouts.ctCDPI_mask);
1005        marker.Tag_opener = simd_andc(LAngle_scope, callouts.ctCDPI_mask);
1006        marker.Ref_opener = simd_andc(lex.RefStart, callouts.ctCDPI_mask);
1007        marker.CD_closer = simd_andc(CD_closer, callouts.ctCDPI_mask);
1008  }
1009  void do_segment(Lex lex[], Marker marker[], Callouts callouts[], Errors errors[], int segment_blocks) {
1010  int i;
1011  for (i = 0; i < segment_blocks; i++)
1012    do_block(lex[i], marker[i], callouts[i], errors[i]);
1013  }
1014  CarryArray<19, 0> carryQ;
1015  };
1016
1017  struct Check_CD_end_error {
1018 
1019  IDISA_ALWAYS_INLINE void do_block(Marker & marker, Callouts & callouts, Errors & errors) {
1020                BitBlock CD_end_error;
1021
1022
1023
1024
1025        CD_end_error = simd_andc(marker.CD_closer, callouts.AttValSpan);
1026        errors.BadSequenceInCharData = CD_end_error;
1027  }
1028  IDISA_ALWAYS_INLINE void do_final_block(Marker & marker, Callouts & callouts, Errors & errors, BitBlock EOF_mask) {
1029                BitBlock CD_end_error;
1030
1031
1032
1033
1034        CD_end_error = simd_andc(marker.CD_closer, callouts.AttValSpan);
1035        errors.BadSequenceInCharData = CD_end_error;
1036  }
1037  void do_segment(Marker marker[], Callouts callouts[], Errors errors[], int segment_blocks) {
1038  int i;
1039  for (i = 0; i < segment_blocks; i++)
1040    do_block(marker[i], callouts[i], errors[i]);
1041  }
1042 
1043  };
1044
1045  struct Prepare_content_buffer {
1046  Prepare_content_buffer() { 
1047 }
1048  IDISA_ALWAYS_INLINE void do_block(U16hi & u16hi, U16lo & u16lo, Lex & lex, Callouts & callouts, Marker & marker) {
1049                BitBlock transition_marks, zeromask, CtCD_marks;
1050
1051                BitBlock tempvar0, tempvar1;
1052
1053
1054        transition_marks = simd_or(simd_or(simd_or(simd_or(callouts.CtCDPI_marks, callouts.AttEq_marks), callouts.StartTag_closers), callouts.EmptyTag_closers), callouts.EndTag_marks);
1055        callouts.MarkupDelimiters = simd_or(callouts.Tag_closers, callouts.CtCDPI_closers);
1056        callouts.StringEnds = simd_or(simd_or(callouts.CtCDPI_closers, callouts.AttCloseQuotes), marker.LAngle);
1057        callouts.delmask = simd_or(callouts.delmask, simd_andc(callouts.TagSpan, simd_or(simd_or(callouts.AttValSpan, transition_marks), callouts.StringEnds)));
1058        tempvar0 = carryQ.BitBlock_exclusive_span(callouts.CtCDPI_marks, callouts.CtCDPI_content_starts, carryQ.get_carry_in(0), 0);
1059        callouts.delmask = simd_or(callouts.delmask, tempvar0);
1060        tempvar1 = carryQ.BitBlock_advance_ci_co(marker.LAngle, carryQ.get_carry_in(1), 1);
1061        callouts.delmask = simd_or(callouts.delmask, simd_and(tempvar1, lex.Exclam));
1062        zeromask = simd_or(simd_or(callouts.delmask, callouts.StringEnds), transition_marks);
1063        CtCD_marks = simd_andc(callouts.CtCDPI_marks, callouts.Symbol_starts);
1064        u16hi.bit_0 = simd_andc(u16hi.bit_0, zeromask);
1065        u16hi.bit_1 = simd_andc(u16hi.bit_1, zeromask);
1066        u16hi.bit_2 = simd_andc(u16hi.bit_2, zeromask);
1067        u16hi.bit_3 = simd_andc(u16hi.bit_3, zeromask);
1068        u16hi.bit_4 = simd_andc(u16hi.bit_4, zeromask);
1069        u16hi.bit_5 = simd_andc(u16hi.bit_5, zeromask);
1070        u16hi.bit_6 = simd_andc(u16hi.bit_6, zeromask);
1071        u16hi.bit_7 = simd_andc(u16hi.bit_7, zeromask);
1072        u16lo.bit_0 = simd_andc(u16lo.bit_0, zeromask);
1073        u16lo.bit_1 = simd_andc(u16lo.bit_1, zeromask);
1074        u16lo.bit_2 = simd_andc(u16lo.bit_2, simd_or(zeromask, marker.Ref_opener));
1075        u16lo.bit_3 = simd_andc(u16lo.bit_3, zeromask);
1076        u16lo.bit_4 = simd_andc(u16lo.bit_4, simd_xor(zeromask, callouts.EmptyTag_closers));
1077        u16lo.bit_5 = simd_andc(u16lo.bit_5, zeromask);
1078        u16lo.bit_5 = simd_or(u16lo.bit_5, callouts.CtCDPI_marks);
1079        u16lo.bit_6 = simd_andc(u16lo.bit_6, simd_xor(simd_xor(zeromask, callouts.EndTag_marks), CtCD_marks));
1080        u16lo.bit_7 = simd_andc(u16lo.bit_7, simd_xor(simd_xor(zeromask, CtCD_marks), callouts.AttEq_marks));
1081        carryQ.CarryQ_Adjust(2);
1082  }
1083  IDISA_ALWAYS_INLINE void do_final_block(U16hi & u16hi, U16lo & u16lo, Lex & lex, Callouts & callouts, Marker & marker, BitBlock EOF_mask) {
1084                BitBlock transition_marks, zeromask, CtCD_marks;
1085
1086                BitBlock tempvar0, tempvar1;
1087
1088
1089        transition_marks = simd_or(simd_or(simd_or(simd_or(callouts.CtCDPI_marks, callouts.AttEq_marks), callouts.StartTag_closers), callouts.EmptyTag_closers), callouts.EndTag_marks);
1090        callouts.MarkupDelimiters = simd_or(callouts.Tag_closers, callouts.CtCDPI_closers);
1091        callouts.StringEnds = simd_or(simd_or(callouts.CtCDPI_closers, callouts.AttCloseQuotes), marker.LAngle);
1092        callouts.delmask = simd_or(callouts.delmask, simd_andc(callouts.TagSpan, simd_or(simd_or(callouts.AttValSpan, transition_marks), callouts.StringEnds)));
1093        tempvar0 = carryQ.BitBlock_exclusive_span(callouts.CtCDPI_marks, callouts.CtCDPI_content_starts, carryQ.get_carry_in(0), 0);
1094        callouts.delmask = simd_or(callouts.delmask, tempvar0);
1095        tempvar1 = carryQ.BitBlock_advance_ci_co(marker.LAngle, carryQ.get_carry_in(1), 1);
1096        callouts.delmask = simd_or(callouts.delmask, simd_and(tempvar1, lex.Exclam));
1097        zeromask = simd_or(simd_or(callouts.delmask, callouts.StringEnds), transition_marks);
1098        CtCD_marks = simd_andc(callouts.CtCDPI_marks, callouts.Symbol_starts);
1099        u16hi.bit_0 = simd_andc(u16hi.bit_0, zeromask);
1100        u16hi.bit_1 = simd_andc(u16hi.bit_1, zeromask);
1101        u16hi.bit_2 = simd_andc(u16hi.bit_2, zeromask);
1102        u16hi.bit_3 = simd_andc(u16hi.bit_3, zeromask);
1103        u16hi.bit_4 = simd_andc(u16hi.bit_4, zeromask);
1104        u16hi.bit_5 = simd_andc(u16hi.bit_5, zeromask);
1105        u16hi.bit_6 = simd_andc(u16hi.bit_6, zeromask);
1106        u16hi.bit_7 = simd_andc(u16hi.bit_7, zeromask);
1107        u16lo.bit_0 = simd_andc(u16lo.bit_0, zeromask);
1108        u16lo.bit_1 = simd_andc(u16lo.bit_1, zeromask);
1109        u16lo.bit_2 = simd_andc(u16lo.bit_2, simd_or(zeromask, marker.Ref_opener));
1110        u16lo.bit_3 = simd_andc(u16lo.bit_3, zeromask);
1111        u16lo.bit_4 = simd_andc(u16lo.bit_4, simd_xor(zeromask, callouts.EmptyTag_closers));
1112        u16lo.bit_5 = simd_andc(u16lo.bit_5, zeromask);
1113        u16lo.bit_5 = simd_or(u16lo.bit_5, callouts.CtCDPI_marks);
1114        u16lo.bit_6 = simd_andc(u16lo.bit_6, simd_xor(simd_xor(zeromask, callouts.EndTag_marks), CtCD_marks));
1115        u16lo.bit_7 = simd_andc(u16lo.bit_7, simd_xor(simd_xor(zeromask, CtCD_marks), callouts.AttEq_marks));
1116  }
1117  void do_segment(U16hi u16hi[], U16lo u16lo[], Lex lex[], Callouts callouts[], Marker marker[], int segment_blocks) {
1118  int i;
1119  for (i = 0; i < segment_blocks; i++)
1120    do_block(u16hi[i], u16lo[i], lex[i], callouts[i], marker[i]);
1121  }
1122  CarryArray<2, 0> carryQ;
1123  };
1124
1125
1126          Parse_refs parse_refs;
1127  Parse_tags parse_tags;
1128  Init_Parameters init_Parameters;
1129  Parse_CtCDPI parse_CtCDPI;
1130  Check_CD_end_error check_CD_end_error;
1131  Prepare_content_buffer prepare_content_buffer;
1132
1133          struct Classify_bytes {
1134  Classify_bytes() { 
1135 }
1136  IDISA_ALWAYS_INLINE void do_block(Parameters & parameters, U16hi & u16hi, U16lo & u16lo, Lex & lex, Callouts & callouts, Errors & errors) {
1137                BitBlock u16hitemp1, u16hitemp2, u16hitemp3, u16hitemp4, u16hitemp5;
1138                BitBlock u16hitemp6, u16hitemp7, u16hi_x00, u16hitemp8, u16hitemp9;
1139                BitBlock u16hitemp10, u16hitemp11, u16hi_hi_surrogate, u16hitemp12;
1140                BitBlock u16hi_lo_surrogate, u16hitemp13, u16hitemp14, u16hitemp15;
1141                BitBlock u16hitemp16, u16hi_xFF, u16hitemp17, u16hitemp18, u16hi_x20, temp1;
1142                BitBlock temp2, temp3, temp4, temp5, xFE_FF, temp6, temp7, x00_x1F, temp8;
1143                BitBlock temp9, temp10, temp11, temp12, temp13, temp14, temp15, temp16, temp17;
1144                BitBlock temp18, temp19, temp20, temp21, temp22, temp23, temp24, temp25;
1145                BitBlock temp26, temp27, temp28, temp29, temp30, temp31, temp32, temp33;
1146                BitBlock temp34, temp35, temp36, temp37, temp38, temp39, temp40, temp41;
1147                BitBlock temp42, temp43, temp44, temp45, temp46, temp47, temp48, temp49;
1148                BitBlock temp50, temp51, temp52, temp53, temp54, temp55, temp56, temp57;
1149                BitBlock temp58, temp59, temp60, temp61, temp62, DEL, temp63, x80_x9F, temp64;
1150                BitBlock temp65, x28, FFFE_FFFF, lexError;
1151
1152                BitBlock tempvar0;
1153
1154
1155        u16hitemp1 = simd_or(u16hi.bit_0, u16hi.bit_1);
1156        u16hitemp2 = simd_or(u16hi.bit_2, u16hi.bit_3);
1157        u16hitemp3 = simd_or(u16hitemp1, u16hitemp2);
1158        u16hitemp4 = simd_or(u16hi.bit_4, u16hi.bit_5);
1159        u16hitemp5 = simd_or(u16hi.bit_6, u16hi.bit_7);
1160        u16hitemp6 = simd_or(u16hitemp4, u16hitemp5);
1161        u16hitemp7 = simd_or(u16hitemp3, u16hitemp6);
1162        u16hi_x00 = simd_not(u16hitemp7);
1163        u16hitemp8 = simd_and(u16hi.bit_0, u16hi.bit_1);
1164        u16hitemp9 = simd_andc(u16hi.bit_3, u16hi.bit_2);
1165        u16hitemp10 = simd_and(u16hitemp8, u16hitemp9);
1166        u16hitemp11 = simd_andc(u16hi.bit_4, u16hi.bit_5);
1167        u16hi_hi_surrogate = simd_and(u16hitemp10, u16hitemp11);
1168        u16hitemp12 = simd_and(u16hi.bit_4, u16hi.bit_5);
1169        u16hi_lo_surrogate = simd_and(u16hitemp10, u16hitemp12);
1170        u16hitemp13 = simd_and(u16hi.bit_2, u16hi.bit_3);
1171        u16hitemp14 = simd_and(u16hitemp8, u16hitemp13);
1172        u16hitemp15 = simd_and(u16hi.bit_6, u16hi.bit_7);
1173        u16hitemp16 = simd_and(u16hitemp12, u16hitemp15);
1174        u16hi_xFF = simd_and(u16hitemp14, u16hitemp16);
1175        u16hitemp17 = simd_andc(u16hi.bit_2, u16hi.bit_3);
1176        u16hitemp18 = simd_andc(u16hitemp17, u16hitemp1);
1177        u16hi_x20 = simd_andc(u16hitemp18, u16hitemp6);
1178        temp1 = simd_and(u16lo.bit_0, u16lo.bit_1);
1179        temp2 = simd_and(u16lo.bit_2, u16lo.bit_3);
1180        temp3 = simd_and(temp1, temp2);
1181        temp4 = simd_and(u16lo.bit_4, u16lo.bit_5);
1182        temp5 = simd_and(temp4, u16lo.bit_6);
1183        xFE_FF = simd_and(temp3, temp5);
1184        temp6 = simd_or(u16lo.bit_0, u16lo.bit_1);
1185        temp7 = simd_or(temp6, u16lo.bit_2);
1186        x00_x1F = simd_not(temp7);
1187        temp8 = simd_or(u16lo.bit_2, u16lo.bit_3);
1188        temp9 = simd_or(temp6, temp8);
1189        temp10 = simd_andc(u16lo.bit_7, u16lo.bit_6);
1190        temp11 = simd_and(temp4, temp10);
1191        lex.CR = simd_andc(temp11, temp9);
1192        temp12 = simd_andc(u16lo.bit_4, u16lo.bit_5);
1193        temp13 = simd_andc(u16lo.bit_6, u16lo.bit_7);
1194        temp14 = simd_and(temp12, temp13);
1195        lex.LF = simd_andc(temp14, temp9);
1196        temp15 = simd_or(temp11, temp14);
1197        temp16 = simd_and(temp12, temp10);
1198        temp17 = simd_or(temp15, temp16);
1199        temp18 = simd_andc(temp17, temp9);
1200        temp19 = simd_andc(u16lo.bit_2, u16lo.bit_3);
1201        temp20 = simd_andc(temp19, temp6);
1202        temp21 = simd_or(u16lo.bit_4, u16lo.bit_5);
1203        temp22 = simd_or(u16lo.bit_6, u16lo.bit_7);
1204        temp23 = simd_or(temp21, temp22);
1205        temp24 = simd_andc(temp20, temp23);
1206        lex.WS = simd_or(temp18, temp24);
1207        temp25 = simd_andc(u16lo.bit_5, u16lo.bit_4);
1208        temp26 = simd_and(temp25, temp13);
1209        lex.RefStart = simd_and(temp20, temp26);
1210        temp27 = simd_andc(temp2, temp6);
1211        temp28 = simd_and(u16lo.bit_6, u16lo.bit_7);
1212        temp29 = simd_and(temp12, temp28);
1213        lex.Semicolon = simd_and(temp27, temp29);
1214        temp30 = simd_andc(temp4, temp22);
1215        lex.LAngle = simd_and(temp27, temp30);
1216        temp31 = simd_and(temp4, temp13);
1217        lex.RAngle = simd_and(temp27, temp31);
1218        temp32 = simd_andc(u16lo.bit_1, u16lo.bit_0);
1219        temp33 = simd_andc(u16lo.bit_3, u16lo.bit_2);
1220        temp34 = simd_and(temp32, temp33);
1221        lex.LBracket = simd_and(temp34, temp29);
1222        lex.RBracket = simd_and(temp34, temp11);
1223        temp35 = simd_andc(temp10, temp21);
1224        lex.Exclam = simd_and(temp20, temp35);
1225        temp36 = simd_and(temp4, temp28);
1226        lex.QMark = simd_and(temp27, temp36);
1227        lex.Hyphen = simd_and(temp20, temp11);
1228        lex.Equals = simd_and(temp27, temp11);
1229        temp37 = simd_and(temp25, temp28);
1230        lex.SQuote = simd_and(temp20, temp37);
1231        temp38 = simd_andc(temp13, temp21);
1232        lex.DQuote = simd_and(temp20, temp38);
1233        lex.Slash = simd_and(temp20, temp36);
1234        temp39 = simd_andc(temp28, temp21);
1235        lex.Hash = simd_and(temp20, temp39);
1236        temp40 = simd_and(temp34, temp36);
1237        temp41 = simd_or(lex.Hyphen, temp40);
1238        temp42 = simd_and(temp20, temp31);
1239        temp43 = simd_or(temp41, temp42);
1240        temp44 = simd_or(u16lo.bit_5, temp28);
1241        temp45 = simd_and(u16lo.bit_4, temp44);
1242        temp46 = simd_andc(temp27, temp45);
1243        temp47 = simd_or(temp43, temp46);
1244        temp48 = simd_andc(temp32, u16lo.bit_2);
1245        temp49 = simd_not(temp45);
1246        temp50 = simd_or(simd_and(u16lo.bit_3, temp49), simd_andc(temp23, u16lo.bit_3));
1247        temp51 = simd_and(temp48, temp50);
1248        temp52 = simd_or(temp47, temp51);
1249        temp53 = simd_and(temp32, u16lo.bit_2);
1250        temp54 = simd_and(temp53, temp50);
1251        lex.NameScan = simd_or(temp52, temp54);
1252        temp55 = simd_and(temp25, temp10);
1253        lex.Pct = simd_and(temp20, temp55);
1254        temp56 = simd_and(temp20, temp14);
1255        temp57 = simd_or(temp56, lex.QMark);
1256        temp58 = simd_and(temp20, temp29);
1257        lex.RepOp = simd_or(temp57, temp58);
1258        temp59 = simd_andc(u16lo.bit_4, temp22);
1259        temp60 = simd_and(temp20, temp59);
1260        temp61 = simd_and(temp32, temp2);
1261        temp62 = simd_and(temp61, temp30);
1262        lex.LContentDelim = simd_or(temp60, temp62);
1263        DEL = simd_and(temp61, temp36);
1264        temp63 = simd_andc(u16lo.bit_0, u16lo.bit_1);
1265        x80_x9F = simd_andc(temp63, u16lo.bit_2);
1266        temp64 = simd_andc(temp63, temp8);
1267        lex.NEL = simd_and(temp64, temp55);
1268        temp65 = simd_andc(temp12, temp22);
1269        x28 = simd_and(temp20, temp65);
1270        lex.LS = simd_and(u16hi_x20, x28);
1271        FFFE_FFFF = simd_and(u16hi_xFF, xFE_FF);
1272        errors.Unicode = simd<1>::constant<0>();
1273        errors.Lexical = simd<1>::constant<0>();
1274        if ((bitblock::any(simd_not(u16hi_x00)) || carryQ.CarryTest(0, 1))) {
1275          if ((bitblock::any(simd_or(u16hi_hi_surrogate, u16hi_lo_surrogate)) || carryQ.CarryTest(0, 1))) {
1276            tempvar0 = carryQ.BitBlock_advance_ci_co(u16hi_hi_surrogate, carryQ.get_carry_in(0), 0);
1277            errors.Unicode = simd_xor(tempvar0, u16hi_lo_surrogate);
1278          }
1279          else {
1280            carryQ.CarryDequeueEnqueue(0, 1);
1281          }
1282          lex.CR = simd_and(lex.CR, u16hi_x00);
1283          lex.LF = simd_and(lex.LF, u16hi_x00);
1284          lex.WS = simd_and(lex.WS, u16hi_x00);
1285          lex.RefStart = simd_and(lex.RefStart, u16hi_x00);
1286          lex.Semicolon = simd_and(lex.Semicolon, u16hi_x00);
1287          lex.LAngle = simd_and(lex.LAngle, u16hi_x00);
1288          lex.RAngle = simd_and(lex.RAngle, u16hi_x00);
1289          lex.LBracket = simd_and(lex.LBracket, u16hi_x00);
1290          lex.RBracket = simd_and(lex.RBracket, u16hi_x00);
1291          lex.Exclam = simd_and(lex.Exclam, u16hi_x00);
1292          lex.QMark = simd_and(lex.QMark, u16hi_x00);
1293          lex.Hyphen = simd_and(lex.Hyphen, u16hi_x00);
1294          lex.Equals = simd_and(lex.Equals, u16hi_x00);
1295          lex.SQuote = simd_and(lex.SQuote, u16hi_x00);
1296          lex.DQuote = simd_and(lex.DQuote, u16hi_x00);
1297          lex.Slash = simd_and(lex.Slash, u16hi_x00);
1298          lex.Hash = simd_and(lex.Hash, u16hi_x00);
1299          lex.NameScan = simd_and(lex.NameScan, u16hi_x00);
1300          lex.NEL = simd_and(lex.NEL, u16hi_x00);
1301          x00_x1F = simd_and(x00_x1F, u16hi_x00);
1302          x80_x9F = simd_and(x80_x9F, u16hi_x00);
1303          DEL = simd_and(DEL, u16hi_x00);
1304          callouts.skipmask = u16hi_hi_surrogate;
1305          lexError = simd_or(simd_andc(x00_x1F, lex.WS), FFFE_FFFF);
1306          if (bitblock::any(parameters.XML_11)) {
1307            lexError = simd_or(lexError, simd_andc(x80_x9F, lex.NEL));
1308            lexError = simd_or(lexError, DEL);
1309            lex.WS = simd_or(lex.WS, simd_or(lex.NEL, lex.LS));
1310          }
1311          if (bitblock::any(lexError)) {
1312            errors.Lexical = lexError;
1313          }
1314        }
1315        else {
1316          carryQ.CarryDequeueEnqueue(0, 1);
1317        }
1318        carryQ.CarryQ_Adjust(1);
1319  }
1320  IDISA_ALWAYS_INLINE void do_final_block(Parameters & parameters, U16hi & u16hi, U16lo & u16lo, Lex & lex, Callouts & callouts, Errors & errors, BitBlock EOF_mask) {
1321                BitBlock u16hitemp1, u16hitemp2, u16hitemp3, u16hitemp4, u16hitemp5;
1322                BitBlock u16hitemp6, u16hitemp7, u16hi_x00, u16hitemp8, u16hitemp9;
1323                BitBlock u16hitemp10, u16hitemp11, u16hi_hi_surrogate, u16hitemp12;
1324                BitBlock u16hi_lo_surrogate, u16hitemp13, u16hitemp14, u16hitemp15;
1325                BitBlock u16hitemp16, u16hi_xFF, u16hitemp17, u16hitemp18, u16hi_x20, temp1;
1326                BitBlock temp2, temp3, temp4, temp5, xFE_FF, temp6, temp7, x00_x1F, temp8;
1327                BitBlock temp9, temp10, temp11, temp12, temp13, temp14, temp15, temp16, temp17;
1328                BitBlock temp18, temp19, temp20, temp21, temp22, temp23, temp24, temp25;
1329                BitBlock temp26, temp27, temp28, temp29, temp30, temp31, temp32, temp33;
1330                BitBlock temp34, temp35, temp36, temp37, temp38, temp39, temp40, temp41;
1331                BitBlock temp42, temp43, temp44, temp45, temp46, temp47, temp48, temp49;
1332                BitBlock temp50, temp51, temp52, temp53, temp54, temp55, temp56, temp57;
1333                BitBlock temp58, temp59, temp60, temp61, temp62, DEL, temp63, x80_x9F, temp64;
1334                BitBlock temp65, x28, FFFE_FFFF, lexError;
1335
1336                BitBlock tempvar0;
1337
1338
1339        u16hitemp1 = simd_or(u16hi.bit_0, u16hi.bit_1);
1340        u16hitemp2 = simd_or(u16hi.bit_2, u16hi.bit_3);
1341        u16hitemp3 = simd_or(u16hitemp1, u16hitemp2);
1342        u16hitemp4 = simd_or(u16hi.bit_4, u16hi.bit_5);
1343        u16hitemp5 = simd_or(u16hi.bit_6, u16hi.bit_7);
1344        u16hitemp6 = simd_or(u16hitemp4, u16hitemp5);
1345        u16hitemp7 = simd_or(u16hitemp3, u16hitemp6);
1346        u16hi_x00 = simd_not(u16hitemp7);
1347        u16hitemp8 = simd_and(u16hi.bit_0, u16hi.bit_1);
1348        u16hitemp9 = simd_andc(u16hi.bit_3, u16hi.bit_2);
1349        u16hitemp10 = simd_and(u16hitemp8, u16hitemp9);
1350        u16hitemp11 = simd_andc(u16hi.bit_4, u16hi.bit_5);
1351        u16hi_hi_surrogate = simd_and(u16hitemp10, u16hitemp11);
1352        u16hitemp12 = simd_and(u16hi.bit_4, u16hi.bit_5);
1353        u16hi_lo_surrogate = simd_and(u16hitemp10, u16hitemp12);
1354        u16hitemp13 = simd_and(u16hi.bit_2, u16hi.bit_3);
1355        u16hitemp14 = simd_and(u16hitemp8, u16hitemp13);
1356        u16hitemp15 = simd_and(u16hi.bit_6, u16hi.bit_7);
1357        u16hitemp16 = simd_and(u16hitemp12, u16hitemp15);
1358        u16hi_xFF = simd_and(u16hitemp14, u16hitemp16);
1359        u16hitemp17 = simd_andc(u16hi.bit_2, u16hi.bit_3);
1360        u16hitemp18 = simd_andc(u16hitemp17, u16hitemp1);
1361        u16hi_x20 = simd_andc(u16hitemp18, u16hitemp6);
1362        temp1 = simd_and(u16lo.bit_0, u16lo.bit_1);
1363        temp2 = simd_and(u16lo.bit_2, u16lo.bit_3);
1364        temp3 = simd_and(temp1, temp2);
1365        temp4 = simd_and(u16lo.bit_4, u16lo.bit_5);
1366        temp5 = simd_and(temp4, u16lo.bit_6);
1367        xFE_FF = simd_and(temp3, temp5);
1368        temp6 = simd_or(u16lo.bit_0, u16lo.bit_1);
1369        temp7 = simd_or(temp6, u16lo.bit_2);
1370        x00_x1F = simd_not(temp7);
1371        temp8 = simd_or(u16lo.bit_2, u16lo.bit_3);
1372        temp9 = simd_or(temp6, temp8);
1373        temp10 = simd_andc(u16lo.bit_7, u16lo.bit_6);
1374        temp11 = simd_and(temp4, temp10);
1375        lex.CR = simd_andc(temp11, temp9);
1376        temp12 = simd_andc(u16lo.bit_4, u16lo.bit_5);
1377        temp13 = simd_andc(u16lo.bit_6, u16lo.bit_7);
1378        temp14 = simd_and(temp12, temp13);
1379        lex.LF = simd_andc(temp14, temp9);
1380        temp15 = simd_or(temp11, temp14);
1381        temp16 = simd_and(temp12, temp10);
1382        temp17 = simd_or(temp15, temp16);
1383        temp18 = simd_andc(temp17, temp9);
1384        temp19 = simd_andc(u16lo.bit_2, u16lo.bit_3);
1385        temp20 = simd_andc(temp19, temp6);
1386        temp21 = simd_or(u16lo.bit_4, u16lo.bit_5);
1387        temp22 = simd_or(u16lo.bit_6, u16lo.bit_7);
1388        temp23 = simd_or(temp21, temp22);
1389        temp24 = simd_andc(temp20, temp23);
1390        lex.WS = simd_or(temp18, temp24);
1391        temp25 = simd_andc(u16lo.bit_5, u16lo.bit_4);
1392        temp26 = simd_and(temp25, temp13);
1393        lex.RefStart = simd_and(temp20, temp26);
1394        temp27 = simd_andc(temp2, temp6);
1395        temp28 = simd_and(u16lo.bit_6, u16lo.bit_7);
1396        temp29 = simd_and(temp12, temp28);
1397        lex.Semicolon = simd_and(temp27, temp29);
1398        temp30 = simd_andc(temp4, temp22);
1399        lex.LAngle = simd_and(temp27, temp30);
1400        temp31 = simd_and(temp4, temp13);
1401        lex.RAngle = simd_and(temp27, temp31);
1402        temp32 = simd_andc(u16lo.bit_1, u16lo.bit_0);
1403        temp33 = simd_andc(u16lo.bit_3, u16lo.bit_2);
1404        temp34 = simd_and(temp32, temp33);
1405        lex.LBracket = simd_and(temp34, temp29);
1406        lex.RBracket = simd_and(temp34, temp11);
1407        temp35 = simd_andc(temp10, temp21);
1408        lex.Exclam = simd_and(temp20, temp35);
1409        temp36 = simd_and(temp4, temp28);
1410        lex.QMark = simd_and(temp27, temp36);
1411        lex.Hyphen = simd_and(temp20, temp11);
1412        lex.Equals = simd_and(temp27, temp11);
1413        temp37 = simd_and(temp25, temp28);
1414        lex.SQuote = simd_and(temp20, temp37);
1415        temp38 = simd_andc(temp13, temp21);
1416        lex.DQuote = simd_and(temp20, temp38);
1417        lex.Slash = simd_and(temp20, temp36);
1418        temp39 = simd_andc(temp28, temp21);
1419        lex.Hash = simd_and(temp20, temp39);
1420        temp40 = simd_and(temp34, temp36);
1421        temp41 = simd_or(lex.Hyphen, temp40);
1422        temp42 = simd_and(temp20, temp31);
1423        temp43 = simd_or(temp41, temp42);
1424        temp44 = simd_or(u16lo.bit_5, temp28);
1425        temp45 = simd_and(u16lo.bit_4, temp44);
1426        temp46 = simd_andc(temp27, temp45);
1427        temp47 = simd_or(temp43, temp46);
1428        temp48 = simd_andc(temp32, u16lo.bit_2);
1429        temp49 = simd_not(temp45);
1430        temp50 = simd_or(simd_and(u16lo.bit_3, temp49), simd_andc(temp23, u16lo.bit_3));
1431        temp51 = simd_and(temp48, temp50);
1432        temp52 = simd_or(temp47, temp51);
1433        temp53 = simd_and(temp32, u16lo.bit_2);
1434        temp54 = simd_and(temp53, temp50);
1435        lex.NameScan = simd_or(temp52, temp54);
1436        temp55 = simd_and(temp25, temp10);
1437        lex.Pct = simd_and(temp20, temp55);
1438        temp56 = simd_and(temp20, temp14);
1439        temp57 = simd_or(temp56, lex.QMark);
1440        temp58 = simd_and(temp20, temp29);
1441        lex.RepOp = simd_or(temp57, temp58);
1442        temp59 = simd_andc(u16lo.bit_4, temp22);
1443        temp60 = simd_and(temp20, temp59);
1444        temp61 = simd_and(temp32, temp2);
1445        temp62 = simd_and(temp61, temp30);
1446        lex.LContentDelim = simd_or(temp60, temp62);
1447        DEL = simd_and(temp61, temp36);
1448        temp63 = simd_andc(u16lo.bit_0, u16lo.bit_1);
1449        x80_x9F = simd_andc(temp63, u16lo.bit_2);
1450        temp64 = simd_andc(temp63, temp8);
1451        lex.NEL = simd_and(temp64, temp55);
1452        temp65 = simd_andc(temp12, temp22);
1453        x28 = simd_and(temp20, temp65);
1454        lex.LS = simd_and(u16hi_x20, x28);
1455        FFFE_FFFF = simd_and(u16hi_xFF, xFE_FF);
1456        errors.Unicode = simd<1>::constant<0>();
1457        errors.Lexical = simd<1>::constant<0>();
1458        if ((bitblock::any(simd_not(u16hi_x00)) || carryQ.CarryTest(0, 1))) {
1459          if ((bitblock::any(simd_or(u16hi_hi_surrogate, u16hi_lo_surrogate)) || carryQ.CarryTest(0, 1))) {
1460            tempvar0 = carryQ.BitBlock_advance_ci_co(u16hi_hi_surrogate, carryQ.get_carry_in(0), 0);
1461            errors.Unicode = simd_xor(tempvar0, u16hi_lo_surrogate);
1462          }
1463          else {
1464            carryQ.CarryDequeueEnqueue(0, 1);
1465          }
1466          lex.CR = simd_and(lex.CR, u16hi_x00);
1467          lex.LF = simd_and(lex.LF, u16hi_x00);
1468          lex.WS = simd_and(lex.WS, u16hi_x00);
1469          lex.RefStart = simd_and(lex.RefStart, u16hi_x00);
1470          lex.Semicolon = simd_and(lex.Semicolon, u16hi_x00);
1471          lex.LAngle = simd_and(lex.LAngle, u16hi_x00);
1472          lex.RAngle = simd_and(lex.RAngle, u16hi_x00);
1473          lex.LBracket = simd_and(lex.LBracket, u16hi_x00);
1474          lex.RBracket = simd_and(lex.RBracket, u16hi_x00);
1475          lex.Exclam = simd_and(lex.Exclam, u16hi_x00);
1476          lex.QMark = simd_and(lex.QMark, u16hi_x00);
1477          lex.Hyphen = simd_and(lex.Hyphen, u16hi_x00);
1478          lex.Equals = simd_and(lex.Equals, u16hi_x00);
1479          lex.SQuote = simd_and(lex.SQuote, u16hi_x00);
1480          lex.DQuote = simd_and(lex.DQuote, u16hi_x00);
1481          lex.Slash = simd_and(lex.Slash, u16hi_x00);
1482          lex.Hash = simd_and(lex.Hash, u16hi_x00);
1483          lex.NameScan = simd_and(lex.NameScan, u16hi_x00);
1484          lex.NEL = simd_and(lex.NEL, u16hi_x00);
1485          x00_x1F = simd_and(x00_x1F, u16hi_x00);
1486          x80_x9F = simd_and(x80_x9F, u16hi_x00);
1487          DEL = simd_and(DEL, u16hi_x00);
1488          callouts.skipmask = u16hi_hi_surrogate;
1489          lexError = simd_or(simd_andc(x00_x1F, lex.WS), FFFE_FFFF);
1490          if (bitblock::any(parameters.XML_11)) {
1491            lexError = simd_or(lexError, simd_andc(x80_x9F, lex.NEL));
1492            lexError = simd_or(lexError, DEL);
1493            lex.WS = simd_or(lex.WS, simd_or(lex.NEL, lex.LS));
1494          }
1495          if (bitblock::any(simd_and(lexError, EOF_mask))) {
1496            errors.Lexical = lexError;
1497          }
1498        }
1499        else {
1500          carryQ.CarryDequeueEnqueue(0, 1);
1501        }
1502  }
1503  void do_segment(Parameters parameters[], U16hi u16hi[], U16lo u16lo[], Lex lex[], Callouts callouts[], Errors errors[], int segment_blocks) {
1504  int i;
1505  for (i = 0; i < segment_blocks; i++)
1506    do_block(parameters[i], u16hi[i], u16lo[i], lex[i], callouts[i], errors[i]);
1507  }
1508  CarryArray<1, 0> carryQ;
1509  };
1510
1511  struct Normalize_WS {
1512  Normalize_WS() { 
1513 }
1514  IDISA_ALWAYS_INLINE void do_block(Parameters & parameters, Lex & lex, U16hi & u16hi, U16lo & u16lo, Callouts & callouts, Marker & marker) {
1515                BitBlock CRLF, CRNEL, WS_in_AttVal;
1516
1517                BitBlock tempvar0, tempvar1;
1518
1519
1520        if ((bitblock::any(lex.CR) || carryQ.CarryTest(0, 1))) {
1521          u16lo.bit_5 = simd_xor(u16lo.bit_5, lex.CR);
1522          u16lo.bit_6 = simd_xor(u16lo.bit_6, lex.CR);
1523          u16lo.bit_7 = simd_xor(u16lo.bit_7, lex.CR);
1524          tempvar0 = carryQ.BitBlock_advance_ci_co(lex.CR, carryQ.get_carry_in(0), 0);
1525          CRLF = simd_and(tempvar0, lex.LF);
1526          callouts.delmask = simd_or(callouts.delmask, CRLF);
1527          lex.LF = simd_or(lex.LF, lex.CR);
1528          lex.LF = simd_xor(lex.LF, CRLF);
1529          callouts.skipmask = simd_or(callouts.skipmask, CRLF);
1530        }
1531        else {
1532          carryQ.CarryDequeueEnqueue(0, 1);
1533        }
1534        if ((bitblock::any(parameters.XML_11) || carryQ.CarryTest(1, 1))) {
1535          if ((bitblock::any(lex.NEL) || carryQ.CarryTest(1, 1))) {
1536            u16lo.bit_0 = simd_xor(u16lo.bit_0, lex.NEL);
1537            u16lo.bit_5 = simd_xor(u16lo.bit_5, lex.NEL);
1538            u16lo.bit_6 = simd_xor(u16lo.bit_6, lex.NEL);
1539            u16lo.bit_7 = simd_xor(u16lo.bit_7, lex.NEL);
1540            lex.LF = simd_or(lex.LF, lex.NEL);
1541            if ((bitblock::any(lex.CR) || carryQ.CarryTest(1, 1))) {
1542              tempvar1 = carryQ.BitBlock_advance_ci_co(lex.CR, carryQ.get_carry_in(1), 1);
1543              CRNEL = simd_and(tempvar1, lex.NEL);
1544              callouts.delmask = simd_or(callouts.delmask, CRNEL);
1545              lex.LF = simd_xor(lex.LF, CRNEL);
1546              callouts.skipmask = simd_or(callouts.skipmask, CRNEL);
1547            }
1548            else {
1549              carryQ.CarryDequeueEnqueue(1, 1);
1550            }
1551          }
1552          else {
1553            carryQ.CarryDequeueEnqueue(1, 1);
1554          }
1555          if (bitblock::any(lex.LS)) {
1556            u16hi.bit_2 = simd_xor(u16hi.bit_2, lex.LS);
1557            u16lo.bit_2 = simd_xor(u16lo.bit_2, lex.LS);
1558            u16lo.bit_6 = simd_xor(u16lo.bit_6, lex.LS);
1559            lex.LF = simd_or(lex.LF, lex.LS);
1560          }
1561        }
1562        else {
1563          carryQ.CarryDequeueEnqueue(1, 1);
1564        }
1565        WS_in_AttVal = simd_and(lex.WS, callouts.AttValSpan);
1566        if (bitblock::any(WS_in_AttVal)) {
1567          u16lo.bit_2 = simd_or(u16lo.bit_2, WS_in_AttVal);
1568          u16lo.bit_3 = simd_andc(u16lo.bit_3, WS_in_AttVal);
1569          u16lo.bit_4 = simd_andc(u16lo.bit_4, WS_in_AttVal);
1570          u16lo.bit_5 = simd_andc(u16lo.bit_5, WS_in_AttVal);
1571          u16lo.bit_6 = simd_andc(u16lo.bit_6, WS_in_AttVal);
1572          u16lo.bit_7 = simd_andc(u16lo.bit_7, WS_in_AttVal);
1573        }
1574        carryQ.CarryQ_Adjust(2);
1575  }
1576  IDISA_ALWAYS_INLINE void do_final_block(Parameters & parameters, Lex & lex, U16hi & u16hi, U16lo & u16lo, Callouts & callouts, Marker & marker, BitBlock EOF_mask) {
1577                BitBlock CRLF, CRNEL, WS_in_AttVal;
1578
1579                BitBlock tempvar0, tempvar1;
1580
1581
1582        if ((bitblock::any(lex.CR) || carryQ.CarryTest(0, 1))) {
1583          u16lo.bit_5 = simd_xor(u16lo.bit_5, lex.CR);
1584          u16lo.bit_6 = simd_xor(u16lo.bit_6, lex.CR);
1585          u16lo.bit_7 = simd_xor(u16lo.bit_7, lex.CR);
1586          tempvar0 = carryQ.BitBlock_advance_ci_co(lex.CR, carryQ.get_carry_in(0), 0);
1587          CRLF = simd_and(tempvar0, lex.LF);
1588          callouts.delmask = simd_or(callouts.delmask, CRLF);
1589          lex.LF = simd_or(lex.LF, lex.CR);
1590          lex.LF = simd_xor(lex.LF, CRLF);
1591          callouts.skipmask = simd_or(callouts.skipmask, CRLF);
1592        }
1593        else {
1594          carryQ.CarryDequeueEnqueue(0, 1);
1595        }
1596        if ((bitblock::any(parameters.XML_11) || carryQ.CarryTest(1, 1))) {
1597          if ((bitblock::any(lex.NEL) || carryQ.CarryTest(1, 1))) {
1598            u16lo.bit_0 = simd_xor(u16lo.bit_0, lex.NEL);
1599            u16lo.bit_5 = simd_xor(u16lo.bit_5, lex.NEL);
1600            u16lo.bit_6 = simd_xor(u16lo.bit_6, lex.NEL);
1601            u16lo.bit_7 = simd_xor(u16lo.bit_7, lex.NEL);
1602            lex.LF = simd_or(lex.LF, lex.NEL);
1603            if ((bitblock::any(lex.CR) || carryQ.CarryTest(1, 1))) {
1604              tempvar1 = carryQ.BitBlock_advance_ci_co(lex.CR, carryQ.get_carry_in(1), 1);
1605              CRNEL = simd_and(tempvar1, lex.NEL);
1606              callouts.delmask = simd_or(callouts.delmask, CRNEL);
1607              lex.LF = simd_xor(lex.LF, CRNEL);
1608              callouts.skipmask = simd_or(callouts.skipmask, CRNEL);
1609            }
1610            else {
1611              carryQ.CarryDequeueEnqueue(1, 1);
1612            }
1613          }
1614          else {
1615            carryQ.CarryDequeueEnqueue(1, 1);
1616          }
1617          if (bitblock::any(lex.LS)) {
1618            u16hi.bit_2 = simd_xor(u16hi.bit_2, lex.LS);
1619            u16lo.bit_2 = simd_xor(u16lo.bit_2, lex.LS);
1620            u16lo.bit_6 = simd_xor(u16lo.bit_6, lex.LS);
1621            lex.LF = simd_or(lex.LF, lex.LS);
1622          }
1623        }
1624        else {
1625          carryQ.CarryDequeueEnqueue(1, 1);
1626        }
1627        WS_in_AttVal = simd_and(lex.WS, callouts.AttValSpan);
1628        if (bitblock::any(WS_in_AttVal)) {
1629          u16lo.bit_2 = simd_or(u16lo.bit_2, WS_in_AttVal);
1630          u16lo.bit_3 = simd_andc(u16lo.bit_3, WS_in_AttVal);
1631          u16lo.bit_4 = simd_andc(u16lo.bit_4, WS_in_AttVal);
1632          u16lo.bit_5 = simd_andc(u16lo.bit_5, WS_in_AttVal);
1633          u16lo.bit_6 = simd_andc(u16lo.bit_6, WS_in_AttVal);
1634          u16lo.bit_7 = simd_andc(u16lo.bit_7, WS_in_AttVal);
1635        }
1636  }
1637  void do_segment(Parameters parameters[], Lex lex[], U16hi u16hi[], U16lo u16lo[], Callouts callouts[], Marker marker[], int segment_blocks) {
1638  int i;
1639  for (i = 0; i < segment_blocks; i++)
1640    do_block(parameters[i], lex[i], u16hi[i], u16lo[i], callouts[i], marker[i]);
1641  }
1642  CarryArray<2, 0> carryQ;
1643  };
1644
1645
1646          Classify_bytes classify_bytes;
1647  Normalize_WS normalize_WS;
1648
1649#undef NoteXercesXMLErr
1650#undef error_tracker_NoteError
1651
1652
1653        XMLCh * buildOutputStream
1654        (
1655                const Marker    &                               marker
1656                , const Callouts  &                             callouts
1657                ,       U16hi     &                             u16hi
1658                ,       U16lo     &                             u16lo
1659                , const XMLByte   *                             source
1660                , const size_t                                  offset
1661                ,               ContentStream &                 contentStream
1662                ,       XMLCh *                                 contentStreamPtr
1663                ,               StringPtrArray &                stringEndArray
1664                , const XMLCh     ** &                  stringEndPtr
1665                ,       unsigned int &                  refMarkupCount
1666                ,       unsigned int &                  refSymbolCount
1667                ,               XMLComplexRefArray &    complexRefArray
1668                ,               XMLSize_t &                             complexRefCount
1669        );
1670
1671        XMLCh * buildInternalOutputStream
1672        (
1673                const Marker    &                       marker
1674                , const Callouts  &                     callouts
1675                ,       U16hi     &         u16hi
1676                ,       U16lo     &         u16lo
1677                , const XMLCh *                         source
1678                ,       XMLCh *                         contentStreamPtr
1679                ,               StringPtrArray &        stringEndArray
1680                , const XMLCh     ** &      stringEndPtr
1681        );
1682
1683
1684        IDISA_ALWAYS_INLINE
1685        void transpose(const BytePack * const in, U16hi & u16h, U16lo & u16l, const bool swapped)
1686        {
1687                BytePack h[8];
1688                BytePack l[8];
1689
1690                if (!swapped)
1691                {
1692                        for(int i=0; i<8; i++)
1693                        {
1694                                const BytePack a = bitblock::load_unaligned(&in[i * 2]);
1695                                const BytePack b = bitblock::load_unaligned(&in[i * 2 + 1]);
1696                                h[i] = hsimd<16>::packh(b, a);
1697                                l[i] = hsimd<16>::packl(b, a);
1698                        }
1699                }
1700                else
1701                {
1702                        for(int i=0; i<8; i++)
1703                        {
1704                                const BytePack a = bitblock::load_unaligned(&in[i * 2]);
1705                                const BytePack b = bitblock::load_unaligned(&in[i * 2 + 1]);
1706                                l[i] = hsimd<16>::packh(b, a);
1707                                h[i] = hsimd<16>::packl(b, a);
1708                        }
1709                }
1710
1711                s2p(h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7],
1712                        u16h.bit_0, u16h.bit_1, u16h.bit_2, u16h.bit_3,
1713                        u16h.bit_4, u16h.bit_5, u16h.bit_6, u16h.bit_7);
1714
1715                s2p(l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7],
1716                        u16l.bit_0, u16l.bit_1, u16l.bit_2, u16l.bit_3,
1717                        u16l.bit_4, u16l.bit_5, u16l.bit_6, u16l.bit_7);
1718        }
1719
1720        IDISA_ALWAYS_INLINE
1721        void transpose(const BytePack * const in, U16hi & u16h, U16lo & u16l, const BitBlock EOF_mask, const bool swapped)
1722        {
1723                transpose(in, u16h, u16l, swapped);
1724
1725                u16l.bit_0 = simd_and(u16l.bit_0, EOF_mask);
1726                u16l.bit_1 = simd_and(u16l.bit_1, EOF_mask);
1727                u16l.bit_2 = simd_and(u16l.bit_2, EOF_mask);
1728                u16l.bit_3 = simd_and(u16l.bit_3, EOF_mask);
1729                u16l.bit_4 = simd_and(u16l.bit_4, EOF_mask);
1730                u16l.bit_5 = simd_and(u16l.bit_5, EOF_mask);
1731                u16l.bit_6 = simd_and(u16l.bit_6, EOF_mask);
1732                u16l.bit_7 = simd_and(u16l.bit_7, EOF_mask);
1733
1734                u16h.bit_0 = simd_and(u16h.bit_0, EOF_mask);
1735                u16h.bit_1 = simd_and(u16h.bit_1, EOF_mask);
1736                u16h.bit_2 = simd_and(u16h.bit_2, EOF_mask);
1737                u16h.bit_3 = simd_and(u16h.bit_3, EOF_mask);
1738                u16h.bit_4 = simd_and(u16h.bit_4, EOF_mask);
1739                u16h.bit_5 = simd_and(u16h.bit_5, EOF_mask);
1740                u16h.bit_6 = simd_and(u16h.bit_6, EOF_mask);
1741                u16h.bit_7 = simd_and(u16h.bit_7, EOF_mask);
1742        }
1743
1744        #ifdef CALCULATE_COPY_BACK_POSITION
1745        static uint64_t calculateUnusedSymbols
1746        (
1747                const BitBlock * const  symbolStream
1748                , const unsigned int    avail
1749                , const unsigned int    unused
1750        );
1751
1752        static uint64_t calculateUnusedContent
1753        (
1754                const BitBlock * const  delMaskStream
1755                , const unsigned int    avail
1756                , const unsigned int    unused
1757        );
1758        #endif
1759
1760        void checkErrors(const XMLUTF16CharacterSetAdapter::Errors & errors, const XMLByte * source, XMLLineColTracker & lineCol);
1761
1762        void reportError(const BitBlock fatalErrors, const XMLUTF16CharacterSetAdapter::Errors & errors, const XMLByte * source, XMLLineColTracker & lineCol);
1763
1764        IDISA_ALWAYS_INLINE
1765        MemoryManager * getMemoryManager()
1766        {
1767                return fTranscoder->getMemoryManager();
1768        }
1769
1770protected:
1771
1772        XMLTranscoder * const                                   fTranscoder;
1773        XMLReferenceTable                                               fReferenceTable;
1774        const bool                                                              fSwapped;
1775};
1776
1777#undef LocalCarryDeclare
1778
1779XERCES_CPP_NAMESPACE_END
1780
1781#if !defined(XERCES_TMPLSINC)
1782#include <icxmlc/XMLReferenceTable.c>
1783#endif
1784
1785#endif
Note: See TracBrowser for help on using the repository browser.