source: icXML/icXML-devel/src/icxmlc/XMLUTF8CharacterSetAdapter.hpp @ 2720

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

Initial check-in of icXML 0.8 source files

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