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

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

Various fixes

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