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

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

Various fixes

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