source: trunk/lib_ir/xmlwf/src/xmlwf.cpp @ 3922

Last change on this file since 3922 was 3922, checked in by linmengl, 5 years ago

copy xmlwf in and compile it with ir lib

File size: 85.4 KB
Line 
1// Stream struct and function headers and definitions
2
3#include <simd-lib/bitblock.hpp>
4#include <simd-lib/carryQ.hpp>
5#include <simd-lib/pabloSupport.hpp>
6
7#define LocalCarryDeclare(name, count)\
8CarryArray<count, 0> name;\
9
10BitBlock EOF_mask = simd<1>::constant<1>();
11
12// XMLWF application headers and definitions
13#include <stdio.h>
14#include <stdlib.h>
15#include <errno.h>
16#include <sys/types.h>
17#include <sys/stat.h>
18
19#include <simd-lib/s2p.h>
20#include <simd-lib/buffer.hpp>
21#include <simd-lib/bitblock_iterator.hpp>
22#include <simd-lib/perflib/perfsec.h>
23
24#include <xmldecl.h>
25#include <namechars.h>
26#include <LineColTracker.hpp>
27#include <XMLTestSuiteError.h>
28
29// Define the mappings for pablo.assert_0(strm, errkind) statements which
30// compile to the the form assert_0_error(errkind, strm)
31#include <ErrorTracker.h>
32
33ErrorTracker error_tracker;
34#define assert_0_error(errkind, errstrm) error_tracker.NoteError(errkind, errstrm);
35
36//#define STL_ALIGNED_VECTOR // experimental STL Aligned Vector
37#ifndef STL_ALIGNED_VECTOR
38#include <TagMatcher.hpp>
39#endif
40
41#ifdef STL_ALIGNED_VECTOR // experimental, comment out TagMatcher code to use STL aligned memory vector
42#warning "Compiling with experimental STL_ALIGNED_VECTOR."
43#include <vector>
44#include <simd-lib/stl_aligned_allocator.hpp>
45#endif
46
47#ifdef BUFFER_PROFILING
48    BOM_Table * parser_timer;
49#elif PAPI
50                #define PAPI_EVENTS_COUNT 2
51                int PAPI_EVENTS[PAPI_EVENTS_COUNT] = {PAPI_TOT_CYC, PAPI_BR_MSP};
52    CC * parser_timer;
53#else
54    void * parser_timer;
55#endif
56
57//////////////////////////////////////////////////////////////////////////////////////////
58// Buffer Management // WARNING: Do Not update #defines. Results in TagMatcher errors.
59//////////////////////////////////////////////////////////////////////////////////////////
60#define PADDING_BLOCKS 0
61#define PADDING_SIZE (BLOCK_SIZE * PADDING_BLOCKS)
62#define COPYBACK_BLOCKS 2
63#define COPYBACK_SIZE (BLOCK_SIZE * COPYBACK_BLOCKS)
64#define LOOKAHEAD_BLOCKS 1
65#define LOOKAHEAD_SIZE (BLOCK_SIZE * LOOKAHEAD_BLOCKS)
66#define SEGMENT_BLOCKS  12 // WARNING: TagMatcher.hpp causes xmlconf test suite failures for SEGMENT_BLOCKS < 3.
67#define SEGMENT_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
68#define BUFFER_SIZE (COPYBACK_SIZE + SEGMENT_SIZE + LOOKAHEAD_SIZE + PADDING_SIZE)
69
70//////////////////////////////////////////////////////////////////////////////////////////
71// @ global depends on 'error_tracker' and 'EOF_mask' definitions.
72//////////////////////////////////////////////////////////////////////////////////////////
73typedef char * Bytedata;
74
75  struct Basis_bits {
76  BitBlock bit_0;
77  BitBlock bit_1;
78  BitBlock bit_2;
79  BitBlock bit_3;
80  BitBlock bit_4;
81  BitBlock bit_5;
82  BitBlock bit_6;
83  BitBlock bit_7;
84};
85
86  struct U8 {
87  BitBlock unibyte;
88  BitBlock prefix;
89  BitBlock prefix2;
90  BitBlock prefix3;
91  BitBlock prefix4;
92  BitBlock suffix;
93  BitBlock badprefix;
94  BitBlock xE0;
95  BitBlock xED;
96  BitBlock xF0;
97  BitBlock xF4;
98  BitBlock xA0_xBF;
99  BitBlock x80_x9F;
100  BitBlock x90_xBF;
101  BitBlock x80_x8F;
102  BitBlock xEF;
103  BitBlock xBF;
104  BitBlock xBE;
105  BitBlock scope22;
106  BitBlock scope32;
107  BitBlock scope33;
108  BitBlock scope42;
109  BitBlock scope43;
110  BitBlock scope44;
111  BitBlock xE0_scope;
112  BitBlock xED_scope;
113  BitBlock xF0_scope;
114  BitBlock xF4_scope;
115  BitBlock xEF_scope;
116};
117
118  struct Lex {
119  BitBlock CR;
120  BitBlock LF;
121  BitBlock HT;
122  BitBlock SP;
123  BitBlock CRLF;
124  BitBlock RefStart;
125  BitBlock Semicolon;
126  BitBlock Colon;
127  BitBlock LAngle;
128  BitBlock RAngle;
129  BitBlock LBracket;
130  BitBlock RBracket;
131  BitBlock Exclam;
132  BitBlock QMark;
133  BitBlock Hyphen;
134  BitBlock Equals;
135  BitBlock SQuote;
136  BitBlock DQuote;
137  BitBlock Slash;
138  BitBlock Hash;
139  BitBlock x;
140  BitBlock ASCII_name_start;
141  BitBlock ASCII_name_char;
142  BitBlock NameScan;
143  BitBlock Digit;
144  BitBlock Hex;
145  BitBlock WS;
146};
147
148  struct Marker {
149  BitBlock LAngle_scope;
150  BitBlock Ref_opener;
151  BitBlock CD_closer;
152};
153
154  struct CtCDPI_Callouts {
155  BitBlock Ct_starts;
156  BitBlock Ct_ends;
157  BitBlock CD_starts;
158  BitBlock CD_ends;
159  BitBlock PI_starts;
160  BitBlock PI_name_starts;
161  BitBlock PI_name_ends;
162  BitBlock PI_ends;
163};
164
165  struct Ref_Callouts {
166  BitBlock GenRef_starts;
167  BitBlock GenRef_ends;
168  BitBlock DecRef_starts;
169  BitBlock DecRef_ends;
170  BitBlock HexRef_starts;
171  BitBlock HexRef_ends;
172};
173
174  struct Tag_Callouts {
175  BitBlock ElemName_starts;
176  BitBlock ElemName_ends;
177  BitBlock AttName_starts;
178  BitBlock AttName_ends;
179  BitBlock AttVal_starts;
180  BitBlock AttVal_ends;
181  BitBlock AttVal_spans;
182  BitBlock EmptyTag_marks;
183  BitBlock EndTag_marks;
184};
185
186  struct Check_streams {
187  BitBlock misc_mask;
188  BitBlock non_ascii_name_starts;
189  BitBlock non_ascii_names;
190  BitBlock tag_marks;
191  BitBlock name_follows;
192  BitBlock att_refs;
193};
194
195  struct Parse_refs {
196  Parse_refs() {
197 }
198  IDISA_INLINE void do_block(Lex & lex, Marker & marker, Ref_Callouts & ref_Callouts) {
199                BitBlock ref_error, Ref_scope, NumRef2, NumRef3, HexRef3, ref_error1;
200                BitBlock ref_error2, ref_ends, ref_error3;
201
202
203
204
205        ref_Callouts.GenRef_starts = simd<1>::constant<0>();
206        ref_Callouts.GenRef_ends = simd<1>::constant<0>();
207        ref_Callouts.DecRef_starts = simd<1>::constant<0>();
208        ref_Callouts.DecRef_ends = simd<1>::constant<0>();
209        ref_Callouts.HexRef_starts = simd<1>::constant<0>();
210        ref_Callouts.HexRef_ends = simd<1>::constant<0>();
211        ref_error = simd<1>::constant<0>();
212        if ((bitblock::any(marker.Ref_opener) || carryQ.CarryTest(0, 6))) {
213          carryQ.cq[0] = carryout2carry(pablo_blk_Advance(marker.Ref_opener, carryQ.get_carry_in(0), Ref_scope));
214          NumRef2 = simd_and(Ref_scope, lex.Hash);
215          ref_Callouts.GenRef_starts = simd_andc(Ref_scope, lex.Hash);
216          carryQ.cq[1] = carryout2carry(pablo_blk_Advance(NumRef2, carryQ.get_carry_in(1), NumRef3));
217          HexRef3 = simd_and(NumRef3, lex.x);
218          ref_Callouts.DecRef_starts = simd_andc(NumRef3, lex.x);
219          carryQ.cq[2] = carryout2carry(pablo_blk_Advance(HexRef3, carryQ.get_carry_in(2), ref_Callouts.HexRef_starts));
220          carryQ.cq[3] = carryout2carry(pablo_blk_ScanThru(ref_Callouts.GenRef_starts, lex.NameScan, carryQ.get_carry_in(3), ref_Callouts.GenRef_ends));
221          carryQ.cq[4] = carryout2carry(pablo_blk_ScanThru(ref_Callouts.DecRef_starts, lex.Digit, carryQ.get_carry_in(4), ref_Callouts.DecRef_ends));
222          carryQ.cq[5] = carryout2carry(pablo_blk_ScanThru(ref_Callouts.HexRef_starts, lex.Hex, carryQ.get_carry_in(5), ref_Callouts.HexRef_ends));
223          ref_error1 = simd_andc(ref_Callouts.DecRef_starts, lex.Digit);
224          ref_error2 = simd_andc(ref_Callouts.HexRef_starts, lex.Hex);
225          ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
226          ref_error3 = simd_andc(ref_ends, lex.Semicolon);
227          if (bitblock::any(simd_or(simd_or(ref_error1, ref_error2), ref_error3))) {
228            assert_0_error("Reference error found", simd_or(simd_or(ref_error1, ref_error2), ref_error3));
229          }
230        }
231        else {
232          carryQ.CarryDequeueEnqueue(0, 6);
233        }
234        carryQ.CarryQ_Adjust(6);
235  }
236  IDISA_INLINE void clear() {
237 }
238  void do_final_block(Lex & lex, Marker & marker, Ref_Callouts & ref_Callouts, BitBlock EOF_mask) {
239                BitBlock ref_error, Ref_scope, NumRef2, NumRef3, HexRef3, ref_error1;
240                BitBlock ref_error2, ref_ends, ref_error3;
241
242
243
244
245        ref_Callouts.GenRef_starts = simd<1>::constant<0>();
246        ref_Callouts.GenRef_ends = simd<1>::constant<0>();
247        ref_Callouts.DecRef_starts = simd<1>::constant<0>();
248        ref_Callouts.DecRef_ends = simd<1>::constant<0>();
249        ref_Callouts.HexRef_starts = simd<1>::constant<0>();
250        ref_Callouts.HexRef_ends = simd<1>::constant<0>();
251        ref_error = simd<1>::constant<0>();
252        if ((bitblock::any(marker.Ref_opener) || carryQ.CarryTest(0, 6))) {
253          carryQ.cq[0] = carryout2carry(pablo_blk_Advance(marker.Ref_opener, carryQ.get_carry_in(0), Ref_scope));
254          NumRef2 = simd_and(Ref_scope, lex.Hash);
255          ref_Callouts.GenRef_starts = simd_andc(Ref_scope, lex.Hash);
256          carryQ.cq[1] = carryout2carry(pablo_blk_Advance(NumRef2, carryQ.get_carry_in(1), NumRef3));
257          HexRef3 = simd_and(NumRef3, lex.x);
258          ref_Callouts.DecRef_starts = simd_andc(NumRef3, lex.x);
259          carryQ.cq[2] = carryout2carry(pablo_blk_Advance(HexRef3, carryQ.get_carry_in(2), ref_Callouts.HexRef_starts));
260          carryQ.cq[3] = carryout2carry(pablo_blk_ScanThru(ref_Callouts.GenRef_starts, lex.NameScan, carryQ.get_carry_in(3), ref_Callouts.GenRef_ends));
261          carryQ.cq[4] = carryout2carry(pablo_blk_ScanThru(ref_Callouts.DecRef_starts, lex.Digit, carryQ.get_carry_in(4), ref_Callouts.DecRef_ends));
262          carryQ.cq[5] = carryout2carry(pablo_blk_ScanThru(ref_Callouts.HexRef_starts, lex.Hex, carryQ.get_carry_in(5), ref_Callouts.HexRef_ends));
263          ref_error1 = simd_andc(ref_Callouts.DecRef_starts, lex.Digit);
264          ref_error2 = simd_andc(ref_Callouts.HexRef_starts, lex.Hex);
265          ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
266          ref_error3 = simd_andc(ref_ends, lex.Semicolon);
267          if (bitblock::any(simd_or(simd_or(ref_error1, ref_error2), ref_error3))) {
268            assert_0_error("Reference error found", simd_or(simd_or(ref_error1, ref_error2), ref_error3));
269          }
270        }
271        else {
272          carryQ.CarryDequeueEnqueue(0, 6);
273        }
274  }
275  CarryArray<6, 0> carryQ;
276  };
277
278  struct Parse_tags {
279  Parse_tags() {
280 }
281  IDISA_INLINE void do_block(Lex & lex, Marker & marker, Tag_Callouts & tag_Callouts) {
282                BitBlock EqExpected, AttListEnd, DQuoteDelim, SQuoteDelim, AttListDelim;
283                BitBlock ParseError, AfterWS, AttNameStart, AttNameFollow, AttValPos;
284                BitBlock DQuoteAttVal, SQuoteAttVal, DQuoteAttEnd, SQuoteAttEnd, AttValEnd;
285                BitBlock AttValFollow, STagEnds, EndTagEnds;
286
287
288
289
290        EqExpected = simd<1>::constant<0>();
291        AttListEnd = simd<1>::constant<0>();
292        DQuoteDelim = simd_or(lex.DQuote, lex.LAngle);
293        SQuoteDelim = simd_or(lex.SQuote, lex.LAngle);
294        AttListDelim = simd_or(lex.Slash, lex.RAngle);
295        tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope, lex.Slash);
296        tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope, lex.Slash);
297        carryQ.cq[0] = carryout2carry(pablo_blk_ScanThru(tag_Callouts.ElemName_starts, lex.NameScan, carryQ.get_carry_in(0), tag_Callouts.ElemName_ends));
298        ParseError = simd_and(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
299        tag_Callouts.AttName_starts = simd<1>::constant<0>();
300        tag_Callouts.AttName_ends = simd<1>::constant<0>();
301        tag_Callouts.AttVal_starts = simd<1>::constant<0>();
302        tag_Callouts.AttVal_ends = simd<1>::constant<0>();
303        if ((bitblock::any(simd_and(tag_Callouts.ElemName_ends, lex.WS)) || carryQ.CarryTest(1, 8))) {
304          carryQ.cq[1] = carryout2carry(pablo_blk_ScanThru(tag_Callouts.ElemName_ends, lex.WS, carryQ.get_carry_in(1), AfterWS));
305          AttListEnd = simd_and(AfterWS, AttListDelim);
306          AttNameStart = simd_andc(AfterWS, AttListDelim);
307          if ((bitblock::any(AttNameStart) || carryQ.CarryTest(2, 7))) {
308            ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
309            tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
310            carryQ.cq[2] = carryout2carry(pablo_blk_ScanThru(AttNameStart, lex.NameScan, carryQ.get_carry_in(2), AttNameFollow));
311            tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
312            if ((bitblock::any(simd_and(AttNameFollow, lex.WS)) || carryQ.CarryTest(3, 1))) {
313              carryQ.cq[3] = carryout2carry(pablo_blk_ScanThru(AttNameFollow, lex.WS, carryQ.get_carry_in(3), EqExpected));
314            }
315            else {
316              EqExpected = AttNameFollow;
317              carryQ.CarryDequeueEnqueue(3, 1);
318            }
319            ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
320            carryQ.cq[4] = carryout2carry(pablo_blk_AdvanceThenScanThru(EqExpected, lex.WS, carryQ.get_carry_in(4), AttValPos));
321            tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
322            DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
323            SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
324            carryQ.cq[5] = carryout2carry(pablo_blk_AdvanceThenScanThru(DQuoteAttVal, simd_not(DQuoteDelim), carryQ.get_carry_in(5), DQuoteAttEnd));
325            carryQ.cq[6] = carryout2carry(pablo_blk_AdvanceThenScanThru(SQuoteAttVal, simd_not(SQuoteDelim), carryQ.get_carry_in(6), SQuoteAttEnd));
326            AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
327            ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
328            carryQ.cq[7] = carryout2carry(pablo_blk_Advance(AttValEnd, carryQ.get_carry_in(7), AttValFollow));
329            tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
330            if ((bitblock::any(simd_and(AttValFollow, lex.WS)) || carryQ.CarryTest(8, 1))) {
331              carryQ.cq[8] = carryout2carry(pablo_blk_ScanThru(AttValFollow, lex.WS, carryQ.get_carry_in(8), AfterWS));
332              AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
333              AttNameStart = simd_andc(AfterWS, AttListDelim);
334            }
335            else {
336              AttListEnd = simd_or(AttListEnd, simd_and(AttValFollow, AttListDelim));
337              AttNameStart = simd_andc(AttValFollow, AttListDelim);
338              carryQ.CarryDequeueEnqueue(8, 1);
339            }
340            ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
341            while (bitblock::any(AttNameStart)) {
342              LocalCarryDeclare(subcarryQ, 7);
343              ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
344              tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
345              subcarryQ.cq[0] = carryout2carry(pablo_blk_ScanThru(AttNameStart, lex.NameScan, carry_value_0, AttNameFollow));
346              tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
347              if (bitblock::any(simd_and(AttNameFollow, lex.WS))) {
348                subcarryQ.cq[1] = carryout2carry(pablo_blk_ScanThru(AttNameFollow, lex.WS, carry_value_0, EqExpected));
349              }
350              else {
351                EqExpected = AttNameFollow;
352                subcarryQ.CarryDequeueEnqueue(3, 1);
353              }
354              ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
355              subcarryQ.cq[2] = carryout2carry(pablo_blk_AdvanceThenScanThru(EqExpected, lex.WS, carry_value_0, AttValPos));
356              tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
357              DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
358              SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
359              subcarryQ.cq[3] = carryout2carry(pablo_blk_AdvanceThenScanThru(DQuoteAttVal, simd_not(DQuoteDelim), carry_value_0, DQuoteAttEnd));
360              subcarryQ.cq[4] = carryout2carry(pablo_blk_AdvanceThenScanThru(SQuoteAttVal, simd_not(SQuoteDelim), carry_value_0, SQuoteAttEnd));
361              AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
362              ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
363              subcarryQ.cq[5] = carryout2carry(pablo_blk_Advance(AttValEnd, carry_value_0, AttValFollow));
364              tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
365              if (bitblock::any(simd_and(AttValFollow, lex.WS))) {
366                subcarryQ.cq[6] = carryout2carry(pablo_blk_ScanThru(AttValFollow, lex.WS, carry_value_0, AfterWS));
367                AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
368                AttNameStart = simd_andc(AfterWS, AttListDelim);
369              }
370              else {
371                AttListEnd = simd_or(AttListEnd, simd_and(AttValFollow, AttListDelim));
372                AttNameStart = simd_andc(AttValFollow, AttListDelim);
373                subcarryQ.CarryDequeueEnqueue(8, 1);
374              }
375              ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
376              carryQ.CarryCombine(subcarryQ.cq, 2, 7);
377            }
378          }
379          else {
380            carryQ.CarryDequeueEnqueue(2, 7);
381          }
382        }
383        else {
384          AttListEnd = simd_and(tag_Callouts.ElemName_ends, AttListDelim);
385          ParseError = simd_or(ParseError, simd_andc(tag_Callouts.ElemName_ends, AttListDelim));
386          carryQ.CarryDequeueEnqueue(1, 8);
387        }
388        STagEnds = simd_and(AttListEnd, lex.RAngle);
389        carryQ.cq[9] = carryout2carry(pablo_blk_Advance(simd_and(AttListEnd, lex.Slash), carryQ.get_carry_in(9), tag_Callouts.EmptyTag_marks));
390        ParseError = simd_or(ParseError, simd_andc(tag_Callouts.EmptyTag_marks, lex.RAngle));
391        carryQ.cq[10] = carryout2carry(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks, lex.NameScan, carryQ.get_carry_in(10), EndTagEnds));
392        if ((bitblock::any(simd_and(EndTagEnds, lex.WS)) || carryQ.CarryTest(11, 1))) {
393          carryQ.cq[11] = carryout2carry(pablo_blk_ScanThru(EndTagEnds, lex.WS, carryQ.get_carry_in(11), EndTagEnds));
394        }
395        else {
396          carryQ.CarryDequeueEnqueue(11, 1);
397        }
398        ParseError = simd_or(ParseError, simd_andc(EndTagEnds, lex.RAngle));
399        if (bitblock::any(ParseError)) {
400          assert_0_error("Tag parsing error found", ParseError);
401        }
402        carryQ.cq[12] = carryout2carry(pablo_blk_SpanUpTo(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carryQ.get_carry_in(12), tag_Callouts.AttVal_spans));
403        carryQ.CarryQ_Adjust(13);
404  }
405  IDISA_INLINE void clear() {
406 }
407  void do_final_block(Lex & lex, Marker & marker, Tag_Callouts & tag_Callouts, BitBlock EOF_mask) {
408                BitBlock EqExpected, AttListEnd, DQuoteDelim, SQuoteDelim, AttListDelim;
409                BitBlock ParseError, AfterWS, AttNameStart, AttNameFollow, AttValPos;
410                BitBlock DQuoteAttVal, SQuoteAttVal, DQuoteAttEnd, SQuoteAttEnd, AttValEnd;
411                BitBlock AttValFollow, STagEnds, EndTagEnds;
412
413
414
415
416        EqExpected = simd<1>::constant<0>();
417        AttListEnd = simd<1>::constant<0>();
418        DQuoteDelim = simd_or(lex.DQuote, lex.LAngle);
419        SQuoteDelim = simd_or(lex.SQuote, lex.LAngle);
420        AttListDelim = simd_or(lex.Slash, lex.RAngle);
421        tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope, lex.Slash);
422        tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope, lex.Slash);
423        carryQ.cq[0] = carryout2carry(pablo_blk_ScanThru(tag_Callouts.ElemName_starts, lex.NameScan, carryQ.get_carry_in(0), tag_Callouts.ElemName_ends));
424        ParseError = simd_and(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
425        tag_Callouts.AttName_starts = simd<1>::constant<0>();
426        tag_Callouts.AttName_ends = simd<1>::constant<0>();
427        tag_Callouts.AttVal_starts = simd<1>::constant<0>();
428        tag_Callouts.AttVal_ends = simd<1>::constant<0>();
429        if ((bitblock::any(simd_and(tag_Callouts.ElemName_ends, lex.WS)) || carryQ.CarryTest(1, 8))) {
430          carryQ.cq[1] = carryout2carry(pablo_blk_ScanThru(tag_Callouts.ElemName_ends, lex.WS, carryQ.get_carry_in(1), AfterWS));
431          AttListEnd = simd_and(AfterWS, AttListDelim);
432          AttNameStart = simd_andc(AfterWS, AttListDelim);
433          if ((bitblock::any(simd_and(AttNameStart, EOF_mask)) || carryQ.CarryTest(2, 7))) {
434            ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
435            tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
436            carryQ.cq[2] = carryout2carry(pablo_blk_ScanThru(AttNameStart, lex.NameScan, carryQ.get_carry_in(2), AttNameFollow));
437            tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
438            if ((bitblock::any(simd_and(AttNameFollow, lex.WS)) || carryQ.CarryTest(3, 1))) {
439              carryQ.cq[3] = carryout2carry(pablo_blk_ScanThru(AttNameFollow, lex.WS, carryQ.get_carry_in(3), EqExpected));
440            }
441            else {
442              EqExpected = AttNameFollow;
443              carryQ.CarryDequeueEnqueue(3, 1);
444            }
445            ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
446            carryQ.cq[4] = carryout2carry(pablo_blk_AdvanceThenScanThru(EqExpected, lex.WS, carryQ.get_carry_in(4), AttValPos));
447            tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
448            DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
449            SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
450            carryQ.cq[5] = carryout2carry(pablo_blk_AdvanceThenScanThru(DQuoteAttVal, simd_andc(EOF_mask, DQuoteDelim), carryQ.get_carry_in(5), DQuoteAttEnd));
451            carryQ.cq[6] = carryout2carry(pablo_blk_AdvanceThenScanThru(SQuoteAttVal, simd_andc(EOF_mask, SQuoteDelim), carryQ.get_carry_in(6), SQuoteAttEnd));
452            AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
453            ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
454            carryQ.cq[7] = carryout2carry(pablo_blk_Advance(AttValEnd, carryQ.get_carry_in(7), AttValFollow));
455            tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
456            if ((bitblock::any(simd_and(AttValFollow, lex.WS)) || carryQ.CarryTest(8, 1))) {
457              carryQ.cq[8] = carryout2carry(pablo_blk_ScanThru(AttValFollow, lex.WS, carryQ.get_carry_in(8), AfterWS));
458              AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
459              AttNameStart = simd_andc(AfterWS, AttListDelim);
460            }
461            else {
462              AttListEnd = simd_or(AttListEnd, simd_and(AttValFollow, AttListDelim));
463              AttNameStart = simd_andc(AttValFollow, AttListDelim);
464              carryQ.CarryDequeueEnqueue(8, 1);
465            }
466            ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
467            while (bitblock::any(simd_and(AttNameStart, EOF_mask))) {
468              LocalCarryDeclare(subcarryQ, 7);
469              ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
470              tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
471              subcarryQ.cq[0] = carryout2carry(pablo_blk_ScanThru(AttNameStart, lex.NameScan, carry_value_0, AttNameFollow));
472              tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
473              if (bitblock::any(simd_and(AttNameFollow, lex.WS))) {
474                subcarryQ.cq[1] = carryout2carry(pablo_blk_ScanThru(AttNameFollow, lex.WS, carry_value_0, EqExpected));
475              }
476              else {
477                EqExpected = AttNameFollow;
478                subcarryQ.CarryDequeueEnqueue(3, 1);
479              }
480              ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
481              subcarryQ.cq[2] = carryout2carry(pablo_blk_AdvanceThenScanThru(EqExpected, lex.WS, carry_value_0, AttValPos));
482              tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
483              DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
484              SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
485              subcarryQ.cq[3] = carryout2carry(pablo_blk_AdvanceThenScanThru(DQuoteAttVal, simd_andc(EOF_mask, DQuoteDelim), carry_value_0, DQuoteAttEnd));
486              subcarryQ.cq[4] = carryout2carry(pablo_blk_AdvanceThenScanThru(SQuoteAttVal, simd_andc(EOF_mask, SQuoteDelim), carry_value_0, SQuoteAttEnd));
487              AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
488              ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
489              subcarryQ.cq[5] = carryout2carry(pablo_blk_Advance(AttValEnd, carry_value_0, AttValFollow));
490              tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
491              if (bitblock::any(simd_and(AttValFollow, lex.WS))) {
492                subcarryQ.cq[6] = carryout2carry(pablo_blk_ScanThru(AttValFollow, lex.WS, carry_value_0, AfterWS));
493                AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
494                AttNameStart = simd_andc(AfterWS, AttListDelim);
495              }
496              else {
497                AttListEnd = simd_or(AttListEnd, simd_and(AttValFollow, AttListDelim));
498                AttNameStart = simd_andc(AttValFollow, AttListDelim);
499                subcarryQ.CarryDequeueEnqueue(8, 1);
500              }
501              ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
502              carryQ.CarryCombine(subcarryQ.cq, 2, 7);
503            }
504          }
505          else {
506            carryQ.CarryDequeueEnqueue(2, 7);
507          }
508        }
509        else {
510          AttListEnd = simd_and(tag_Callouts.ElemName_ends, AttListDelim);
511          ParseError = simd_or(ParseError, simd_andc(tag_Callouts.ElemName_ends, AttListDelim));
512          carryQ.CarryDequeueEnqueue(1, 8);
513        }
514        STagEnds = simd_and(AttListEnd, lex.RAngle);
515        carryQ.cq[9] = carryout2carry(pablo_blk_Advance(simd_and(AttListEnd, lex.Slash), carryQ.get_carry_in(9), tag_Callouts.EmptyTag_marks));
516        ParseError = simd_or(ParseError, simd_andc(tag_Callouts.EmptyTag_marks, lex.RAngle));
517        carryQ.cq[10] = carryout2carry(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks, lex.NameScan, carryQ.get_carry_in(10), EndTagEnds));
518        if ((bitblock::any(simd_and(EndTagEnds, lex.WS)) || carryQ.CarryTest(11, 1))) {
519          carryQ.cq[11] = carryout2carry(pablo_blk_ScanThru(EndTagEnds, lex.WS, carryQ.get_carry_in(11), EndTagEnds));
520        }
521        else {
522          carryQ.CarryDequeueEnqueue(11, 1);
523        }
524        ParseError = simd_or(ParseError, simd_andc(EndTagEnds, lex.RAngle));
525        if (bitblock::any(ParseError)) {
526          assert_0_error("Tag parsing error found", ParseError);
527        }
528        carryQ.cq[12] = carryout2carry(pablo_blk_SpanUpTo(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carryQ.get_carry_in(12), tag_Callouts.AttVal_spans));
529  }
530  CarryArray<13, 0> carryQ;
531  };
532
533  struct Classify_bytes_Validate_utf8 {
534  Classify_bytes_Validate_utf8() {
535 }
536  IDISA_INLINE void do_block(Basis_bits & basis_bits, Lex & lex, U8 & u8) {
537                BitBlock temp1, temp2, temp3, temp4, temp5, temp6, temp7, temp8, temp9, temp10;
538                BitBlock temp11, temp12, temp13, temp14, temp15, temp16, temp17, temp18;
539                BitBlock temp19, temp20, temp21, temp22, temp23, temp24, temp25, temp26;
540                BitBlock temp27, temp28, temp29, temp30, temp31, temp32, temp33, temp34;
541                BitBlock temp35, temp36, temp37, temp38, temp39, temp40, temp41, temp42;
542                BitBlock temp43, temp44, temp45, temp46, temp47, temp48, x00_x1F, temp49;
543                BitBlock temp50, temp51, temp52, temp53, temp54, temp55, temp56, temp57;
544                BitBlock temp58, temp59, temp60, temp61, temp62, temp63, temp64, temp65;
545                BitBlock lex_error, u8_error, u8_FFFE_FFFF, u8anyscope, temp66, temp67, temp68;
546                BitBlock temp69, temp70, temp71, xE0, xED, xF0, temp72, xF4, xEF, temp73;
547                BitBlock E0_F0_scope, ED_F4_scope, u8lastscope, u8error1, u8error2, u8error3;
548                BitBlock u8error4, EF_BF_pending, u8mismatch;
549
550
551
552
553        temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
554        temp2 = simd_andc(basis_bits.bit_2, basis_bits.bit_3);
555        temp3 = simd_andc(temp2, temp1);
556        temp4 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
557        temp5 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
558        temp6 = simd_and(temp4, temp5);
559        lex.RefStart = simd_and(temp3, temp6);
560        temp7 = simd_and(basis_bits.bit_2, basis_bits.bit_3);
561        temp8 = simd_andc(temp7, temp1);
562        temp9 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
563        temp10 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
564        temp11 = simd_and(temp9, temp10);
565        lex.Semicolon = simd_and(temp8, temp11);
566        temp12 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
567        temp13 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
568        temp14 = simd_andc(temp12, temp13);
569        lex.LAngle = simd_and(temp8, temp14);
570        temp15 = simd_and(temp12, temp5);
571        lex.RAngle = simd_and(temp8, temp15);
572        temp16 = simd_andc(basis_bits.bit_1, basis_bits.bit_0);
573        temp17 = simd_andc(basis_bits.bit_3, basis_bits.bit_2);
574        temp18 = simd_and(temp16, temp17);
575        lex.LBracket = simd_and(temp18, temp11);
576        temp19 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
577        temp20 = simd_and(temp12, temp19);
578        lex.RBracket = simd_and(temp18, temp20);
579        temp21 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
580        temp22 = simd_andc(temp19, temp21);
581        lex.Exclam = simd_and(temp3, temp22);
582        temp23 = simd_and(temp12, temp10);
583        lex.QMark = simd_and(temp8, temp23);
584        lex.Hyphen = simd_and(temp3, temp20);
585        lex.Equals = simd_and(temp8, temp20);
586        temp24 = simd_and(temp4, temp10);
587        lex.SQuote = simd_and(temp3, temp24);
588        temp25 = simd_andc(temp5, temp21);
589        lex.DQuote = simd_and(temp3, temp25);
590        lex.Slash = simd_and(temp3, temp23);
591        temp26 = simd_andc(temp10, temp21);
592        lex.Hash = simd_and(temp3, temp26);
593        temp27 = simd_and(temp16, temp7);
594        temp28 = simd_andc(temp9, temp13);
595        lex.x = simd_and(temp27, temp28);
596        temp29 = simd_and(temp9, temp5);
597        lex.Colon = simd_and(temp8, temp29);
598        temp30 = simd_and(temp18, temp23);
599        temp31 = simd_or(temp30, lex.Colon);
600        temp32 = simd_andc(temp16, basis_bits.bit_2);
601        temp33 = simd_or(basis_bits.bit_5, temp10);
602        temp34 = simd_and(basis_bits.bit_4, temp33);
603        temp35 = simd_not(temp34);
604        temp36 = simd_or(temp21, temp13);
605        temp37 = simd_or(simd_and(basis_bits.bit_3, temp35), simd_andc(temp36, basis_bits.bit_3));
606        temp38 = simd_and(temp32, temp37);
607        temp39 = simd_or(temp31, temp38);
608        temp40 = simd_and(temp16, basis_bits.bit_2);
609        temp41 = simd_and(temp40, temp37);
610        lex.ASCII_name_start = simd_or(temp39, temp41);
611        temp42 = simd_or(temp30, lex.Hyphen);
612        temp43 = simd_and(temp3, temp15);
613        temp44 = simd_or(temp42, temp43);
614        temp45 = simd_andc(temp8, temp34);
615        temp46 = simd_or(temp44, temp45);
616        temp47 = simd_or(temp46, temp38);
617        lex.ASCII_name_char = simd_or(temp47, temp41);
618        lex.NameScan = simd_or(lex.ASCII_name_char, basis_bits.bit_0);
619        temp48 = simd_or(temp1, basis_bits.bit_2);
620        x00_x1F = simd_not(temp48);
621        temp49 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
622        temp50 = simd_or(temp1, temp49);
623        lex.CR = simd_andc(temp20, temp50);
624        lex.LF = simd_andc(temp29, temp50);
625        temp51 = simd_and(temp9, temp19);
626        lex.HT = simd_andc(temp51, temp50);
627        lex.SP = simd_andc(temp3, temp36);
628        temp52 = simd_or(temp20, temp29);
629        temp53 = simd_or(temp52, temp51);
630        temp54 = simd_andc(temp53, temp50);
631        lex.WS = simd_or(temp54, lex.SP);
632        temp55 = simd_or(basis_bits.bit_5, basis_bits.bit_6);
633        temp56 = simd_and(basis_bits.bit_4, temp55);
634        lex.Digit = simd_andc(temp8, temp56);
635        temp57 = simd_andc(temp16, temp49);
636        temp58 = simd_andc(temp57, basis_bits.bit_4);
637        temp59 = simd_not(temp10);
638        temp60 = simd_or(simd_and(basis_bits.bit_5, temp59), simd_andc(temp13, basis_bits.bit_5));
639        temp61 = simd_and(temp58, temp60);
640        temp62 = simd_or(lex.Digit, temp61);
641        temp63 = simd_and(temp16, temp2);
642        temp64 = simd_andc(temp63, basis_bits.bit_4);
643        temp65 = simd_and(temp64, temp60);
644        lex.Hex = simd_or(temp62, temp65);
645        lex_error = simd_andc(x00_x1F, lex.WS);
646        if (bitblock::any(lex_error)) {
647          assert_0_error("Error: illegal character", lex_error);
648        }
649        u8.unibyte = simd_not(basis_bits.bit_0);
650        u8.suffix = simd<1>::constant<0>();
651        u8_error = simd<1>::constant<0>();
652        u8_FFFE_FFFF = simd<1>::constant<0>();
653        u8anyscope = simd<1>::constant<0>();
654        if ((bitblock::any(basis_bits.bit_0) || carryQ.CarryTest(0, 10))) {
655          u8.prefix = simd_and(basis_bits.bit_0, basis_bits.bit_1);
656          u8.prefix2 = simd_andc(u8.prefix, basis_bits.bit_2);
657          u8.prefix3 = simd_and(u8.prefix, temp2);
658          u8.prefix4 = simd_and(u8.prefix, temp7);
659          u8.suffix = simd_andc(basis_bits.bit_0, basis_bits.bit_1);
660          temp66 = simd_andc(u8.prefix, temp49);
661          temp67 = simd_or(temp21, basis_bits.bit_6);
662          temp68 = simd_andc(temp66, temp67);
663          temp69 = simd_and(basis_bits.bit_5, temp13);
664          temp70 = simd_or(basis_bits.bit_4, temp69);
665          temp71 = simd_and(u8.prefix4, temp70);
666          u8.badprefix = simd_or(temp68, temp71);
667          u8_error = u8.badprefix;
668          carryQ.cq[0] = carryout2carry(pablo_blk_Advance(u8.prefix2, carryQ.get_carry_in(0), u8.scope22));
669          u8anyscope = u8.scope22;
670          if ((bitblock::any(simd_or(u8.prefix3, u8.prefix4)) || carryQ.CarryTest(1, 9))) {
671            xE0 = simd_andc(u8.prefix3, temp36);
672            xED = simd_and(u8.prefix3, temp20);
673            xF0 = simd_andc(u8.prefix4, temp36);
674            temp72 = simd_andc(temp4, temp13);
675            xF4 = simd_and(u8.prefix4, temp72);
676            u8.xA0_xBF = simd_and(u8.suffix, basis_bits.bit_2);
677            u8.x80_x9F = simd_andc(u8.suffix, basis_bits.bit_2);
678            u8.x90_xBF = simd_and(u8.suffix, temp49);
679            u8.x80_x8F = simd_andc(u8.suffix, temp49);
680            xEF = simd_and(u8.prefix3, temp23);
681            temp73 = simd_and(u8.suffix, temp7);
682            u8.xBF = simd_and(temp73, temp23);
683            u8.xBE = simd_and(temp73, temp15);
684            carryQ.cq[1] = carryout2carry(pablo_blk_Advance(u8.prefix3, carryQ.get_carry_in(1), u8.scope32));
685            carryQ.cq[2] = carryout2carry(pablo_blk_Advance(u8.scope32, carryQ.get_carry_in(2), u8.scope33));
686            carryQ.cq[3] = carryout2carry(pablo_blk_Advance(u8.prefix4, carryQ.get_carry_in(3), u8.scope42));
687            carryQ.cq[4] = carryout2carry(pablo_blk_Advance(u8.scope42, carryQ.get_carry_in(4), u8.scope43));
688            carryQ.cq[5] = carryout2carry(pablo_blk_Advance(u8.scope43, carryQ.get_carry_in(5), u8.scope44));
689            carryQ.cq[6] = carryout2carry(pablo_blk_Advance(simd_or(xE0, xF0), carryQ.get_carry_in(6), E0_F0_scope));
690            carryQ.cq[7] = carryout2carry(pablo_blk_Advance(simd_or(xED, xF4), carryQ.get_carry_in(7), ED_F4_scope));
691            u8.xE0_scope = simd_and(u8.scope32, E0_F0_scope);
692            u8.xED_scope = simd_and(u8.scope32, ED_F4_scope);
693            u8.xF0_scope = simd_and(u8.scope42, E0_F0_scope);
694            u8.xF4_scope = simd_and(u8.scope42, ED_F4_scope);
695            carryQ.cq[8] = carryout2carry(pablo_blk_Advance(xEF, carryQ.get_carry_in(8), u8.xEF_scope));
696            u8lastscope = simd_or(simd_or(u8.scope22, u8.scope33), u8.scope44);
697            u8anyscope = simd_or(simd_or(simd_or(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
698            u8error1 = simd_and(u8.xE0_scope, u8.x80_x9F);
699            u8error2 = simd_and(u8.xED_scope, u8.xA0_xBF);
700            u8error3 = simd_and(u8.xF0_scope, u8.x80_x8F);
701            u8error4 = simd_and(u8.xF4_scope, u8.x90_xBF);
702            u8_error = simd_or(u8_error, simd_or(simd_or(simd_or(u8error1, u8error2), u8error3), u8error4));
703            carryQ.cq[9] = carryout2carry(pablo_blk_Advance(simd_and(u8.xEF_scope, u8.xBF), carryQ.get_carry_in(9), EF_BF_pending));
704            u8_FFFE_FFFF = simd_and(EF_BF_pending, simd_or(u8.xBE, u8.xBF));
705          }
706          else {
707            carryQ.CarryDequeueEnqueue(1, 9);
708          }
709          u8mismatch = simd_xor(u8anyscope, u8.suffix);
710          if (bitblock::any(simd_or(simd_or(u8_error, u8mismatch), u8_FFFE_FFFF))) {
711            assert_0_error("UTF-8 error found", simd_or(simd_or(u8_error, u8mismatch), u8_FFFE_FFFF));
712          }
713        }
714        else {
715          carryQ.CarryDequeueEnqueue(0, 10);
716        }
717        carryQ.CarryQ_Adjust(10);
718  }
719  IDISA_INLINE void clear() {
720 }
721  void do_final_block(Basis_bits & basis_bits, Lex & lex, U8 & u8, BitBlock EOF_mask) {
722                BitBlock temp1, temp2, temp3, temp4, temp5, temp6, temp7, temp8, temp9, temp10;
723                BitBlock temp11, temp12, temp13, temp14, temp15, temp16, temp17, temp18;
724                BitBlock temp19, temp20, temp21, temp22, temp23, temp24, temp25, temp26;
725                BitBlock temp27, temp28, temp29, temp30, temp31, temp32, temp33, temp34;
726                BitBlock temp35, temp36, temp37, temp38, temp39, temp40, temp41, temp42;
727                BitBlock temp43, temp44, temp45, temp46, temp47, temp48, x00_x1F, temp49;
728                BitBlock temp50, temp51, temp52, temp53, temp54, temp55, temp56, temp57;
729                BitBlock temp58, temp59, temp60, temp61, temp62, temp63, temp64, temp65;
730                BitBlock lex_error, u8_error, u8_FFFE_FFFF, u8anyscope, temp66, temp67, temp68;
731                BitBlock temp69, temp70, temp71, xE0, xED, xF0, temp72, xF4, xEF, temp73;
732                BitBlock E0_F0_scope, ED_F4_scope, u8lastscope, u8error1, u8error2, u8error3;
733                BitBlock u8error4, EF_BF_pending, u8mismatch;
734
735
736
737
738        temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
739        temp2 = simd_andc(basis_bits.bit_2, basis_bits.bit_3);
740        temp3 = simd_andc(temp2, temp1);
741        temp4 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
742        temp5 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
743        temp6 = simd_and(temp4, temp5);
744        lex.RefStart = simd_and(temp3, temp6);
745        temp7 = simd_and(basis_bits.bit_2, basis_bits.bit_3);
746        temp8 = simd_andc(temp7, temp1);
747        temp9 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
748        temp10 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
749        temp11 = simd_and(temp9, temp10);
750        lex.Semicolon = simd_and(temp8, temp11);
751        temp12 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
752        temp13 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
753        temp14 = simd_andc(temp12, temp13);
754        lex.LAngle = simd_and(temp8, temp14);
755        temp15 = simd_and(temp12, temp5);
756        lex.RAngle = simd_and(temp8, temp15);
757        temp16 = simd_andc(basis_bits.bit_1, basis_bits.bit_0);
758        temp17 = simd_andc(basis_bits.bit_3, basis_bits.bit_2);
759        temp18 = simd_and(temp16, temp17);
760        lex.LBracket = simd_and(temp18, temp11);
761        temp19 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
762        temp20 = simd_and(temp12, temp19);
763        lex.RBracket = simd_and(temp18, temp20);
764        temp21 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
765        temp22 = simd_andc(temp19, temp21);
766        lex.Exclam = simd_and(temp3, temp22);
767        temp23 = simd_and(temp12, temp10);
768        lex.QMark = simd_and(temp8, temp23);
769        lex.Hyphen = simd_and(temp3, temp20);
770        lex.Equals = simd_and(temp8, temp20);
771        temp24 = simd_and(temp4, temp10);
772        lex.SQuote = simd_and(temp3, temp24);
773        temp25 = simd_andc(temp5, temp21);
774        lex.DQuote = simd_and(temp3, temp25);
775        lex.Slash = simd_and(temp3, temp23);
776        temp26 = simd_andc(temp10, temp21);
777        lex.Hash = simd_and(temp3, temp26);
778        temp27 = simd_and(temp16, temp7);
779        temp28 = simd_andc(temp9, temp13);
780        lex.x = simd_and(temp27, temp28);
781        temp29 = simd_and(temp9, temp5);
782        lex.Colon = simd_and(temp8, temp29);
783        temp30 = simd_and(temp18, temp23);
784        temp31 = simd_or(temp30, lex.Colon);
785        temp32 = simd_andc(temp16, basis_bits.bit_2);
786        temp33 = simd_or(basis_bits.bit_5, temp10);
787        temp34 = simd_and(basis_bits.bit_4, temp33);
788        temp35 = simd_not(temp34);
789        temp36 = simd_or(temp21, temp13);
790        temp37 = simd_or(simd_and(basis_bits.bit_3, temp35), simd_andc(temp36, basis_bits.bit_3));
791        temp38 = simd_and(temp32, temp37);
792        temp39 = simd_or(temp31, temp38);
793        temp40 = simd_and(temp16, basis_bits.bit_2);
794        temp41 = simd_and(temp40, temp37);
795        lex.ASCII_name_start = simd_or(temp39, temp41);
796        temp42 = simd_or(temp30, lex.Hyphen);
797        temp43 = simd_and(temp3, temp15);
798        temp44 = simd_or(temp42, temp43);
799        temp45 = simd_andc(temp8, temp34);
800        temp46 = simd_or(temp44, temp45);
801        temp47 = simd_or(temp46, temp38);
802        lex.ASCII_name_char = simd_or(temp47, temp41);
803        lex.NameScan = simd_or(lex.ASCII_name_char, basis_bits.bit_0);
804        temp48 = simd_or(temp1, basis_bits.bit_2);
805        x00_x1F = simd_not(temp48);
806        temp49 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
807        temp50 = simd_or(temp1, temp49);
808        lex.CR = simd_andc(temp20, temp50);
809        lex.LF = simd_andc(temp29, temp50);
810        temp51 = simd_and(temp9, temp19);
811        lex.HT = simd_andc(temp51, temp50);
812        lex.SP = simd_andc(temp3, temp36);
813        temp52 = simd_or(temp20, temp29);
814        temp53 = simd_or(temp52, temp51);
815        temp54 = simd_andc(temp53, temp50);
816        lex.WS = simd_or(temp54, lex.SP);
817        temp55 = simd_or(basis_bits.bit_5, basis_bits.bit_6);
818        temp56 = simd_and(basis_bits.bit_4, temp55);
819        lex.Digit = simd_andc(temp8, temp56);
820        temp57 = simd_andc(temp16, temp49);
821        temp58 = simd_andc(temp57, basis_bits.bit_4);
822        temp59 = simd_not(temp10);
823        temp60 = simd_or(simd_and(basis_bits.bit_5, temp59), simd_andc(temp13, basis_bits.bit_5));
824        temp61 = simd_and(temp58, temp60);
825        temp62 = simd_or(lex.Digit, temp61);
826        temp63 = simd_and(temp16, temp2);
827        temp64 = simd_andc(temp63, basis_bits.bit_4);
828        temp65 = simd_and(temp64, temp60);
829        lex.Hex = simd_or(temp62, temp65);
830        lex_error = simd_andc(x00_x1F, lex.WS);
831        if (bitblock::any(simd_and(lex_error, EOF_mask))) {
832          assert_0_error("Error: illegal character", simd_and(lex_error, EOF_mask));
833        }
834        u8.unibyte = simd_not(basis_bits.bit_0);
835        u8.suffix = simd<1>::constant<0>();
836        u8_error = simd<1>::constant<0>();
837        u8_FFFE_FFFF = simd<1>::constant<0>();
838        u8anyscope = simd<1>::constant<0>();
839        if ((bitblock::any(basis_bits.bit_0) || carryQ.CarryTest(0, 10))) {
840          u8.prefix = simd_and(basis_bits.bit_0, basis_bits.bit_1);
841          u8.prefix2 = simd_andc(u8.prefix, basis_bits.bit_2);
842          u8.prefix3 = simd_and(u8.prefix, temp2);
843          u8.prefix4 = simd_and(u8.prefix, temp7);
844          u8.suffix = simd_andc(basis_bits.bit_0, basis_bits.bit_1);
845          temp66 = simd_andc(u8.prefix, temp49);
846          temp67 = simd_or(temp21, basis_bits.bit_6);
847          temp68 = simd_andc(temp66, temp67);
848          temp69 = simd_and(basis_bits.bit_5, temp13);
849          temp70 = simd_or(basis_bits.bit_4, temp69);
850          temp71 = simd_and(u8.prefix4, temp70);
851          u8.badprefix = simd_or(temp68, temp71);
852          u8_error = u8.badprefix;
853          carryQ.cq[0] = carryout2carry(pablo_blk_Advance(u8.prefix2, carryQ.get_carry_in(0), u8.scope22));
854          u8anyscope = u8.scope22;
855          if ((bitblock::any(simd_or(u8.prefix3, u8.prefix4)) || carryQ.CarryTest(1, 9))) {
856            xE0 = simd_andc(u8.prefix3, temp36);
857            xED = simd_and(u8.prefix3, temp20);
858            xF0 = simd_andc(u8.prefix4, temp36);
859            temp72 = simd_andc(temp4, temp13);
860            xF4 = simd_and(u8.prefix4, temp72);
861            u8.xA0_xBF = simd_and(u8.suffix, basis_bits.bit_2);
862            u8.x80_x9F = simd_andc(u8.suffix, basis_bits.bit_2);
863            u8.x90_xBF = simd_and(u8.suffix, temp49);
864            u8.x80_x8F = simd_andc(u8.suffix, temp49);
865            xEF = simd_and(u8.prefix3, temp23);
866            temp73 = simd_and(u8.suffix, temp7);
867            u8.xBF = simd_and(temp73, temp23);
868            u8.xBE = simd_and(temp73, temp15);
869            carryQ.cq[1] = carryout2carry(pablo_blk_Advance(u8.prefix3, carryQ.get_carry_in(1), u8.scope32));
870            carryQ.cq[2] = carryout2carry(pablo_blk_Advance(u8.scope32, carryQ.get_carry_in(2), u8.scope33));
871            carryQ.cq[3] = carryout2carry(pablo_blk_Advance(u8.prefix4, carryQ.get_carry_in(3), u8.scope42));
872            carryQ.cq[4] = carryout2carry(pablo_blk_Advance(u8.scope42, carryQ.get_carry_in(4), u8.scope43));
873            carryQ.cq[5] = carryout2carry(pablo_blk_Advance(u8.scope43, carryQ.get_carry_in(5), u8.scope44));
874            carryQ.cq[6] = carryout2carry(pablo_blk_Advance(simd_or(xE0, xF0), carryQ.get_carry_in(6), E0_F0_scope));
875            carryQ.cq[7] = carryout2carry(pablo_blk_Advance(simd_or(xED, xF4), carryQ.get_carry_in(7), ED_F4_scope));
876            u8.xE0_scope = simd_and(u8.scope32, E0_F0_scope);
877            u8.xED_scope = simd_and(u8.scope32, ED_F4_scope);
878            u8.xF0_scope = simd_and(u8.scope42, E0_F0_scope);
879            u8.xF4_scope = simd_and(u8.scope42, ED_F4_scope);
880            carryQ.cq[8] = carryout2carry(pablo_blk_Advance(xEF, carryQ.get_carry_in(8), u8.xEF_scope));
881            u8lastscope = simd_or(simd_or(u8.scope22, u8.scope33), u8.scope44);
882            u8anyscope = simd_or(simd_or(simd_or(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
883            u8error1 = simd_and(u8.xE0_scope, u8.x80_x9F);
884            u8error2 = simd_and(u8.xED_scope, u8.xA0_xBF);
885            u8error3 = simd_and(u8.xF0_scope, u8.x80_x8F);
886            u8error4 = simd_and(u8.xF4_scope, u8.x90_xBF);
887            u8_error = simd_or(u8_error, simd_or(simd_or(simd_or(u8error1, u8error2), u8error3), u8error4));
888            carryQ.cq[9] = carryout2carry(pablo_blk_Advance(simd_and(u8.xEF_scope, u8.xBF), carryQ.get_carry_in(9), EF_BF_pending));
889            u8_FFFE_FFFF = simd_and(EF_BF_pending, simd_or(u8.xBE, u8.xBF));
890          }
891          else {
892            carryQ.CarryDequeueEnqueue(1, 9);
893          }
894          u8mismatch = simd_xor(u8anyscope, u8.suffix);
895          if (bitblock::any(simd_or(simd_or(u8_error, u8mismatch), u8_FFFE_FFFF))) {
896            assert_0_error("UTF-8 error found", simd_or(simd_or(u8_error, u8mismatch), u8_FFFE_FFFF));
897          }
898        }
899        else {
900          carryQ.CarryDequeueEnqueue(0, 10);
901        }
902  }
903  CarryArray<10, 0> carryQ;
904  };
905
906  struct Parse_CtCDPI {
907  Parse_CtCDPI() {
908carryQ.cq[4] = carryQ.carry_flip(carryQ.cq[4]);
909 }
910  IDISA_INLINE void do_block(Bytedata & bytedata, Lex & lex, Marker & marker, CtCDPI_Callouts & ctCDPI_Callouts, Check_streams & check_streams) {
911                BitBlock CtCDPI_starts, CtCDPI_ends, ctCDPI_mask, v, w, v1, w1, LAngle_scope;
912                BitBlock PI_opener, CtCD_opener, CtCDPI_opener, CD_closer, DoubleHyphen;
913                BitBlock DoubleRBracket, PI_closer, CtCDPI_Cursor, PI_Cursor, CD_Ct_Cursor;
914                BitBlock CD_Cursor, Ct_Cursor, PI_name_end, PI_error, PI_noWS, check, Ct_error;
915
916                BitBlock tempvar0, tempvar1, tempvar2, tempvar3, tempvar4, tempvar5;
917
918
919        ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
920        ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
921        ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
922        ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
923        ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
924        ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
925        ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
926        ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
927        CtCDPI_starts = simd<1>::constant<0>();
928        CtCDPI_ends = simd<1>::constant<0>();
929        ctCDPI_mask = simd<1>::constant<0>();
930        v = simd_or(lex.LAngle, lex.Hyphen);
931        w = simd_or(lex.Hyphen, lex.QMark);
932        carryQ.cq[0] = carryout2carry(pablo_blk_Advance(v, carryQ.get_carry_in(0), v1));
933        carryQ.cq[1] = carryout2carry(pablo_blk_Advance(w, carryQ.get_carry_in(1), w1));
934        LAngle_scope = simd_andc(v1, w1);
935        PI_opener = simd_and(LAngle_scope, lex.QMark);
936        CtCD_opener = simd_and(LAngle_scope, lex.Exclam);
937        CtCDPI_opener = simd_or(PI_opener, CtCD_opener);
938        CD_closer = simd<1>::constant<0>();
939        DoubleHyphen = simd_and(simd_and(v1, w1), lex.Hyphen);
940        if ((bitblock::any(lex.RBracket) || carryQ.CarryTest(2, 2))) {
941          carryQ.cq[2] = carryout2carry(pablo_blk_Advance(lex.RBracket, carryQ.get_carry_in(2), tempvar0));
942          DoubleRBracket = simd_and(tempvar0, lex.RBracket);
943          carryQ.cq[3] = carryout2carry(pablo_blk_Advance(DoubleRBracket, carryQ.get_carry_in(3), tempvar1));
944          CD_closer = simd_and(tempvar1, lex.RAngle);
945        }
946        else {
947          carryQ.CarryDequeueEnqueue(2, 2);
948        }
949        PI_closer = simd_and(simd_andc(w1, v1), lex.RAngle);
950        carryQ.cq[4] = carryout2carry(pablo_blk_ScanToFirst(CtCDPI_opener, carryQ.get_carry_in(4), CtCDPI_Cursor));
951        if ((bitblock::any(CtCDPI_Cursor) || carryQ.CarryTest(5, 13))) {
952          CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
953          PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
954          carryQ.cq[5] = carryout2carry(pablo_blk_Advance(simd_andc(CtCDPI_Cursor, PI_Cursor), carryQ.get_carry_in(5), CD_Ct_Cursor));
955          CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
956          Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
957          if ((bitblock::any(PI_Cursor) || carryQ.CarryTest(6, 4))) {
958            ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
959            carryQ.cq[6] = carryout2carry(pablo_blk_Advance(PI_Cursor, carryQ.get_carry_in(6), PI_Cursor));
960            ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
961            carryQ.cq[7] = carryout2carry(pablo_blk_ScanThru(PI_Cursor, lex.NameScan, carryQ.get_carry_in(7), PI_name_end));
962            PI_error = simd_and(PI_Cursor, PI_name_end);
963            PI_noWS = simd_andc(PI_name_end, lex.WS);
964            carryQ.cq[8] = carryout2carry(pablo_blk_Advance(PI_noWS, carryQ.get_carry_in(8), tempvar2));
965            PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(tempvar2, PI_closer)));
966            if (bitblock::any(PI_error)) {
967              assert_0_error("Error in PI syntax", PI_error);
968            }
969            ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
970            carryQ.cq[9] = carryout2carry(pablo_blk_ScanThru(PI_name_end, simd_not(PI_closer), carryQ.get_carry_in(9), PI_Cursor));
971            ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
972            CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
973          }
974          else {
975            carryQ.CarryDequeueEnqueue(6, 4);
976          }
977          if ((bitblock::any(CD_Cursor) || carryQ.CarryTest(10, 1))) {
978            check = simd_xor(CD_Cursor, pablo_blk_match<char>(bytedata, "[CDATA[", CD_Cursor, 7));
979            if (bitblock::any(check)) {
980              assert_0_error("CDATA error", check);
981            }
982            ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
983            carryQ.cq[10] = carryout2carry(pablo_blk_ScanThru(CD_Cursor, simd_not(CD_closer), carryQ.get_carry_in(10), CD_Cursor));
984            ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
985            CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
986          }
987          else {
988            carryQ.CarryDequeueEnqueue(10, 1);
989          }
990          if ((bitblock::any(Ct_Cursor) || carryQ.CarryTest(11, 5))) {
991            ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
992            carryQ.cq[11] = carryout2carry(pablo_blk_Advance(Ct_Cursor, carryQ.get_carry_in(11), Ct_Cursor));
993            Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
994            carryQ.cq[12] = carryout2carry(pablo_blk_Advance(Ct_Cursor, carryQ.get_carry_in(12), tempvar3));
995            carryQ.cq[13] = carryout2carry(pablo_blk_Advance(tempvar3, carryQ.get_carry_in(13), Ct_Cursor));
996            carryQ.cq[14] = carryout2carry(pablo_blk_ScanThru(Ct_Cursor, simd_not(DoubleHyphen), carryQ.get_carry_in(14), tempvar4));
997            carryQ.cq[15] = carryout2carry(pablo_blk_Advance(tempvar4, carryQ.get_carry_in(15), Ct_Cursor));
998            if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)))) {
999              assert_0_error("Error in comment syntax", simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)));
1000            }
1001            ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
1002            CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
1003          }
1004          else {
1005            carryQ.CarryDequeueEnqueue(11, 5);
1006          }
1007          CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
1008          carryQ.cq[16] = carryout2carry(pablo_blk_InclusiveSpan(CtCDPI_starts, CtCDPI_ends, carryQ.get_carry_in(16), ctCDPI_mask));
1009          if (bitblock::any(simd<1>::constant<0>())) {
1010            assert_0_error("Error in comment, CDATA or processing instruction syntax", simd<1>::constant<0>());
1011          }
1012          carryQ.cq[17] = carryout2carry(pablo_blk_ScanThru(CtCDPI_Cursor, simd_not(CtCDPI_opener), carryQ.get_carry_in(17), CtCDPI_Cursor));
1013          while (bitblock::any(CtCDPI_Cursor)) {
1014            LocalCarryDeclare(subcarryQ, 13);
1015            CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
1016            PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
1017            subcarryQ.cq[0] = carryout2carry(pablo_blk_Advance(simd_andc(CtCDPI_Cursor, PI_Cursor), carry_value_0, CD_Ct_Cursor));
1018            CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
1019            Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
1020            if (bitblock::any(PI_Cursor)) {
1021              ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
1022              subcarryQ.cq[1] = carryout2carry(pablo_blk_Advance(PI_Cursor, carry_value_0, PI_Cursor));
1023              ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
1024              subcarryQ.cq[2] = carryout2carry(pablo_blk_ScanThru(PI_Cursor, lex.NameScan, carry_value_0, PI_name_end));
1025              PI_error = simd_and(PI_Cursor, PI_name_end);
1026              PI_noWS = simd_andc(PI_name_end, lex.WS);
1027              subcarryQ.cq[3] = carryout2carry(pablo_blk_Advance(PI_noWS, carry_value_0, tempvar2));
1028              PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(tempvar2, PI_closer)));
1029              if (bitblock::any(PI_error)) {
1030                assert_0_error("Error in PI syntax", PI_error);
1031              }
1032              ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
1033              subcarryQ.cq[4] = carryout2carry(pablo_blk_ScanThru(PI_name_end, simd_not(PI_closer), carry_value_0, PI_Cursor));
1034              ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
1035              CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
1036            }
1037            else {
1038              subcarryQ.CarryDequeueEnqueue(6, 4);
1039            }
1040            if (bitblock::any(CD_Cursor)) {
1041              check = simd_xor(CD_Cursor, pablo_blk_match<char>(bytedata, "[CDATA[", CD_Cursor, 7));
1042              if (bitblock::any(check)) {
1043                assert_0_error("CDATA error", check);
1044              }
1045              ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
1046              subcarryQ.cq[5] = carryout2carry(pablo_blk_ScanThru(CD_Cursor, simd_not(CD_closer), carry_value_0, CD_Cursor));
1047              ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
1048              CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
1049            }
1050            else {
1051              subcarryQ.CarryDequeueEnqueue(10, 1);
1052            }
1053            if (bitblock::any(Ct_Cursor)) {
1054              ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
1055              subcarryQ.cq[6] = carryout2carry(pablo_blk_Advance(Ct_Cursor, carry_value_0, Ct_Cursor));
1056              Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
1057              subcarryQ.cq[7] = carryout2carry(pablo_blk_Advance(Ct_Cursor, carry_value_0, tempvar3));
1058              subcarryQ.cq[8] = carryout2carry(pablo_blk_Advance(tempvar3, carry_value_0, Ct_Cursor));
1059              subcarryQ.cq[9] = carryout2carry(pablo_blk_ScanThru(Ct_Cursor, simd_not(DoubleHyphen), carry_value_0, tempvar4));
1060              subcarryQ.cq[10] = carryout2carry(pablo_blk_Advance(tempvar4, carry_value_0, Ct_Cursor));
1061              if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)))) {
1062                assert_0_error("Error in comment syntax", simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)));
1063              }
1064              ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
1065              CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
1066            }
1067            else {
1068              subcarryQ.CarryDequeueEnqueue(11, 5);
1069            }
1070            CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
1071            subcarryQ.cq[11] = carryout2carry(pablo_blk_InclusiveSpan(CtCDPI_starts, CtCDPI_ends, carry_value_0, ctCDPI_mask));
1072            if (bitblock::any(simd<1>::constant<0>())) {
1073              assert_0_error("Error in comment, CDATA or processing instruction syntax", simd<1>::constant<0>());
1074            }
1075            subcarryQ.cq[12] = carryout2carry(pablo_blk_ScanThru(CtCDPI_Cursor, simd_not(CtCDPI_opener), carry_value_0, CtCDPI_Cursor));
1076            carryQ.CarryCombine(subcarryQ.cq, 5, 13);
1077          }
1078        }
1079        else {
1080          carryQ.CarryDequeueEnqueue(5, 13);
1081        }
1082        carryQ.cq[18] = carryout2carry(pablo_blk_InclusiveSpan(simd_or(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), simd_or(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carryQ.get_carry_in(18), tempvar5));
1083        check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS, lex.LAngle), tempvar5), CtCDPI_starts), EOF_mask);
1084        marker.LAngle_scope = simd_andc(LAngle_scope, ctCDPI_mask);
1085        marker.Ref_opener = simd_andc(lex.RefStart, ctCDPI_mask);
1086        marker.CD_closer = simd_andc(CD_closer, ctCDPI_mask);
1087        carryQ.CarryQ_Adjust(17);
1088  }
1089  IDISA_INLINE void clear() {
1090carryQ.cq[4] = carryQ.carry_flip(carryQ.cq[4]);
1091 }
1092  void do_final_block(Bytedata & bytedata, Lex & lex, Marker & marker, CtCDPI_Callouts & ctCDPI_Callouts, Check_streams & check_streams, BitBlock EOF_mask) {
1093                BitBlock CtCDPI_starts, CtCDPI_ends, ctCDPI_mask, v, w, v1, w1, LAngle_scope;
1094                BitBlock PI_opener, CtCD_opener, CtCDPI_opener, CD_closer, DoubleHyphen;
1095                BitBlock DoubleRBracket, PI_closer, CtCDPI_Cursor, PI_Cursor, CD_Ct_Cursor;
1096                BitBlock CD_Cursor, Ct_Cursor, PI_name_end, PI_error, PI_noWS, check, Ct_error;
1097
1098                BitBlock tempvar0, tempvar1, tempvar2, tempvar3, tempvar4, tempvar5;
1099
1100
1101        ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
1102        ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
1103        ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
1104        ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
1105        ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
1106        ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
1107        ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
1108        ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
1109        CtCDPI_starts = simd<1>::constant<0>();
1110        CtCDPI_ends = simd<1>::constant<0>();
1111        ctCDPI_mask = simd<1>::constant<0>();
1112        v = simd_or(lex.LAngle, lex.Hyphen);
1113        w = simd_or(lex.Hyphen, lex.QMark);
1114        carryQ.cq[0] = carryout2carry(pablo_blk_Advance(v, carryQ.get_carry_in(0), v1));
1115        carryQ.cq[1] = carryout2carry(pablo_blk_Advance(w, carryQ.get_carry_in(1), w1));
1116        LAngle_scope = simd_andc(v1, w1);
1117        PI_opener = simd_and(LAngle_scope, lex.QMark);
1118        CtCD_opener = simd_and(LAngle_scope, lex.Exclam);
1119        CtCDPI_opener = simd_or(PI_opener, CtCD_opener);
1120        CD_closer = simd<1>::constant<0>();
1121        DoubleHyphen = simd_and(simd_and(v1, w1), lex.Hyphen);
1122        if ((bitblock::any(lex.RBracket) || carryQ.CarryTest(2, 2))) {
1123          carryQ.cq[2] = carryout2carry(pablo_blk_Advance(lex.RBracket, carryQ.get_carry_in(2), tempvar0));
1124          DoubleRBracket = simd_and(tempvar0, lex.RBracket);
1125          carryQ.cq[3] = carryout2carry(pablo_blk_Advance(DoubleRBracket, carryQ.get_carry_in(3), tempvar1));
1126          CD_closer = simd_and(tempvar1, lex.RAngle);
1127        }
1128        else {
1129          carryQ.CarryDequeueEnqueue(2, 2);
1130        }
1131        PI_closer = simd_and(simd_andc(w1, v1), lex.RAngle);
1132        carryQ.cq[4] = carryout2carry(pablo_blk_ScanToFirst(CtCDPI_opener, carryQ.get_carry_in(4), CtCDPI_Cursor));
1133        if ((bitblock::any(simd_and(CtCDPI_Cursor, EOF_mask)) || carryQ.CarryTest(5, 13))) {
1134          CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
1135          PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
1136          carryQ.cq[5] = carryout2carry(pablo_blk_Advance(simd_andc(CtCDPI_Cursor, PI_Cursor), carryQ.get_carry_in(5), CD_Ct_Cursor));
1137          CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
1138          Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
1139          if ((bitblock::any(PI_Cursor) || carryQ.CarryTest(6, 4))) {
1140            ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
1141            carryQ.cq[6] = carryout2carry(pablo_blk_Advance(PI_Cursor, carryQ.get_carry_in(6), PI_Cursor));
1142            ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
1143            carryQ.cq[7] = carryout2carry(pablo_blk_ScanThru(PI_Cursor, lex.NameScan, carryQ.get_carry_in(7), PI_name_end));
1144            PI_error = simd_and(PI_Cursor, PI_name_end);
1145            PI_noWS = simd_andc(PI_name_end, lex.WS);
1146            carryQ.cq[8] = carryout2carry(pablo_blk_Advance(PI_noWS, carryQ.get_carry_in(8), tempvar2));
1147            PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(tempvar2, PI_closer)));
1148            if (bitblock::any(PI_error)) {
1149              assert_0_error("Error in PI syntax", PI_error);
1150            }
1151            ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
1152            carryQ.cq[9] = carryout2carry(pablo_blk_ScanThru(PI_name_end, simd_andc(EOF_mask, PI_closer), carryQ.get_carry_in(9), PI_Cursor));
1153            ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
1154            CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
1155          }
1156          else {
1157            carryQ.CarryDequeueEnqueue(6, 4);
1158          }
1159          if ((bitblock::any(CD_Cursor) || carryQ.CarryTest(10, 1))) {
1160            check = simd_xor(CD_Cursor, pablo_blk_match<char>(bytedata, "[CDATA[", CD_Cursor, 7));
1161            if (bitblock::any(check)) {
1162              assert_0_error("CDATA error", check);
1163            }
1164            ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
1165            carryQ.cq[10] = carryout2carry(pablo_blk_ScanThru(CD_Cursor, simd_andc(EOF_mask, CD_closer), carryQ.get_carry_in(10), CD_Cursor));
1166            ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
1167            CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
1168          }
1169          else {
1170            carryQ.CarryDequeueEnqueue(10, 1);
1171          }
1172          if ((bitblock::any(Ct_Cursor) || carryQ.CarryTest(11, 5))) {
1173            ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
1174            carryQ.cq[11] = carryout2carry(pablo_blk_Advance(Ct_Cursor, carryQ.get_carry_in(11), Ct_Cursor));
1175            Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
1176            carryQ.cq[12] = carryout2carry(pablo_blk_Advance(Ct_Cursor, carryQ.get_carry_in(12), tempvar3));
1177            carryQ.cq[13] = carryout2carry(pablo_blk_Advance(tempvar3, carryQ.get_carry_in(13), Ct_Cursor));
1178            carryQ.cq[14] = carryout2carry(pablo_blk_ScanThru(Ct_Cursor, simd_andc(EOF_mask, DoubleHyphen), carryQ.get_carry_in(14), tempvar4));
1179            carryQ.cq[15] = carryout2carry(pablo_blk_Advance(tempvar4, carryQ.get_carry_in(15), Ct_Cursor));
1180            if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)))) {
1181              assert_0_error("Error in comment syntax", simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)));
1182            }
1183            ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
1184            CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
1185          }
1186          else {
1187            carryQ.CarryDequeueEnqueue(11, 5);
1188          }
1189          CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
1190          carryQ.cq[16] = carryout2carry(pablo_blk_InclusiveSpan(CtCDPI_starts, CtCDPI_ends, carryQ.get_carry_in(16), ctCDPI_mask));
1191          if (bitblock::any(simd_andc(simd_andc(ctCDPI_mask, EOF_mask), bitblock::slli<1>(simd_not(EOF_mask))))) {
1192            assert_0_error("Error in comment, CDATA or processing instruction syntax", simd_andc(simd_andc(ctCDPI_mask, EOF_mask), bitblock::slli<1>(simd_not(EOF_mask))));
1193          }
1194          carryQ.cq[17] = carryout2carry(pablo_blk_ScanThru(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), carryQ.get_carry_in(17), CtCDPI_Cursor));
1195          while (bitblock::any(simd_and(CtCDPI_Cursor, EOF_mask))) {
1196            LocalCarryDeclare(subcarryQ, 13);
1197            CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
1198            PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
1199            subcarryQ.cq[0] = carryout2carry(pablo_blk_Advance(simd_andc(CtCDPI_Cursor, PI_Cursor), carry_value_0, CD_Ct_Cursor));
1200            CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
1201            Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
1202            if (bitblock::any(PI_Cursor)) {
1203              ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
1204              subcarryQ.cq[1] = carryout2carry(pablo_blk_Advance(PI_Cursor, carry_value_0, PI_Cursor));
1205              ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
1206              subcarryQ.cq[2] = carryout2carry(pablo_blk_ScanThru(PI_Cursor, lex.NameScan, carry_value_0, PI_name_end));
1207              PI_error = simd_and(PI_Cursor, PI_name_end);
1208              PI_noWS = simd_andc(PI_name_end, lex.WS);
1209              subcarryQ.cq[3] = carryout2carry(pablo_blk_Advance(PI_noWS, carry_value_0, tempvar2));
1210              PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(tempvar2, PI_closer)));
1211              if (bitblock::any(PI_error)) {
1212                assert_0_error("Error in PI syntax", PI_error);
1213              }
1214              ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
1215              subcarryQ.cq[4] = carryout2carry(pablo_blk_ScanThru(PI_name_end, simd_andc(EOF_mask, PI_closer), carry_value_0, PI_Cursor));
1216              ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
1217              CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
1218            }
1219            else {
1220              subcarryQ.CarryDequeueEnqueue(6, 4);
1221            }
1222            if (bitblock::any(CD_Cursor)) {
1223              check = simd_xor(CD_Cursor, pablo_blk_match<char>(bytedata, "[CDATA[", CD_Cursor, 7));
1224              if (bitblock::any(check)) {
1225                assert_0_error("CDATA error", check);
1226              }
1227              ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
1228              subcarryQ.cq[5] = carryout2carry(pablo_blk_ScanThru(CD_Cursor, simd_andc(EOF_mask, CD_closer), carry_value_0, CD_Cursor));
1229              ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
1230              CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
1231            }
1232            else {
1233              subcarryQ.CarryDequeueEnqueue(10, 1);
1234            }
1235            if (bitblock::any(Ct_Cursor)) {
1236              ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
1237              subcarryQ.cq[6] = carryout2carry(pablo_blk_Advance(Ct_Cursor, carry_value_0, Ct_Cursor));
1238              Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
1239              subcarryQ.cq[7] = carryout2carry(pablo_blk_Advance(Ct_Cursor, carry_value_0, tempvar3));
1240              subcarryQ.cq[8] = carryout2carry(pablo_blk_Advance(tempvar3, carry_value_0, Ct_Cursor));
1241              subcarryQ.cq[9] = carryout2carry(pablo_blk_ScanThru(Ct_Cursor, simd_andc(EOF_mask, DoubleHyphen), carry_value_0, tempvar4));
1242              subcarryQ.cq[10] = carryout2carry(pablo_blk_Advance(tempvar4, carry_value_0, Ct_Cursor));
1243              if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)))) {
1244                assert_0_error("Error in comment syntax", simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)));
1245              }
1246              ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
1247              CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
1248            }
1249            else {
1250              subcarryQ.CarryDequeueEnqueue(11, 5);
1251            }
1252            CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
1253            subcarryQ.cq[11] = carryout2carry(pablo_blk_InclusiveSpan(CtCDPI_starts, CtCDPI_ends, carry_value_0, ctCDPI_mask));
1254            if (bitblock::any(simd_andc(simd_andc(ctCDPI_mask, EOF_mask), bitblock::slli<1>(simd_not(EOF_mask))))) {
1255              assert_0_error("Error in comment, CDATA or processing instruction syntax", simd_andc(simd_andc(ctCDPI_mask, EOF_mask), bitblock::slli<1>(simd_not(EOF_mask))));
1256            }
1257            subcarryQ.cq[12] = carryout2carry(pablo_blk_ScanThru(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), carry_value_0, CtCDPI_Cursor));
1258            carryQ.CarryCombine(subcarryQ.cq, 5, 13);
1259          }
1260        }
1261        else {
1262          carryQ.CarryDequeueEnqueue(5, 13);
1263        }
1264        carryQ.cq[18] = carryout2carry(pablo_blk_InclusiveSpan(simd_or(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), simd_or(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carryQ.get_carry_in(18), tempvar5));
1265        check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS, lex.LAngle), tempvar5), CtCDPI_starts), EOF_mask);
1266        marker.LAngle_scope = simd_andc(LAngle_scope, ctCDPI_mask);
1267        marker.Ref_opener = simd_andc(lex.RefStart, ctCDPI_mask);
1268        marker.CD_closer = simd_andc(CD_closer, ctCDPI_mask);
1269  }
1270  CarryArray<19, 0> carryQ;
1271  };
1272
1273  struct Do_check_streams {
1274
1275  IDISA_INLINE void do_block(Marker & marker, Tag_Callouts & tag_Callouts, Check_streams & check_streams) {
1276
1277
1278
1279
1280
1281        if (bitblock::any(simd_andc(marker.CD_closer, tag_Callouts.AttVal_spans))) {
1282          assert_0_error("Error: ]]> in text", simd_andc(marker.CD_closer, tag_Callouts.AttVal_spans));
1283        }
1284        check_streams.tag_marks = simd_or(simd_or(simd_or(tag_Callouts.EmptyTag_marks, tag_Callouts.ElemName_starts), tag_Callouts.EndTag_marks), tag_Callouts.AttName_starts);
1285        check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends, tag_Callouts.AttName_ends);
1286        check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans, marker.Ref_opener);
1287  }
1288  IDISA_INLINE void clear() {
1289 }
1290  void do_final_block(Marker & marker, Tag_Callouts & tag_Callouts, Check_streams & check_streams, BitBlock EOF_mask) {
1291
1292
1293
1294
1295
1296        if (bitblock::any(simd_andc(marker.CD_closer, tag_Callouts.AttVal_spans))) {
1297          assert_0_error("Error: ]]> in text", simd_andc(marker.CD_closer, tag_Callouts.AttVal_spans));
1298        }
1299        check_streams.tag_marks = simd_or(simd_or(simd_or(tag_Callouts.EmptyTag_marks, tag_Callouts.ElemName_starts), tag_Callouts.EndTag_marks), tag_Callouts.AttName_starts);
1300        check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends, tag_Callouts.AttName_ends);
1301        check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans, marker.Ref_opener);
1302  }
1303
1304  };
1305
1306  struct Validate_xml_names {
1307  Validate_xml_names() {
1308 }
1309  IDISA_INLINE void do_block(CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Tag_Callouts & tag_Callouts, Lex & lex, U8 & u8, Check_streams & check_streams) {
1310                BitBlock PI_names, GenRefs, ElemNames, AttNames, qname_stream, ncname_stream;
1311                BitBlock name_stream, name_start, name_cursor, void_prefix_err, namespace_sep;
1312                BitBlock local_part_start, local_part_err, colon2_err, ncname_err;
1313
1314                BitBlock tempvar0, tempvar1, tempvar2, tempvar3;
1315
1316
1317        carryQ.cq[0] = carryout2carry(pablo_blk_SpanUpTo(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carryQ.get_carry_in(0), PI_names));
1318        carryQ.cq[1] = carryout2carry(pablo_blk_SpanUpTo(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carryQ.get_carry_in(1), GenRefs));
1319        carryQ.cq[2] = carryout2carry(pablo_blk_SpanUpTo(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carryQ.get_carry_in(2), ElemNames));
1320        carryQ.cq[3] = carryout2carry(pablo_blk_SpanUpTo(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carryQ.get_carry_in(3), AttNames));
1321        qname_stream = simd_or(ElemNames, AttNames);
1322        ncname_stream = simd_or(PI_names, GenRefs);
1323        name_stream = simd_or(qname_stream, ncname_stream);
1324        carryQ.cq[4] = carryout2carry(pablo_blk_Advance(name_stream, carryQ.get_carry_in(4), tempvar0));
1325        name_start = simd_andc(name_stream, tempvar0);
1326        carryQ.cq[5] = carryout2carry(pablo_blk_Advance(name_stream, carryQ.get_carry_in(5), tempvar1));
1327        name_cursor = simd_andc(name_stream, tempvar1);
1328        void_prefix_err = simd_and(name_cursor, lex.Colon);
1329        carryQ.cq[6] = carryout2carry(pablo_blk_ScanThru(name_cursor, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(6), tempvar2));
1330        namespace_sep = simd_and(tempvar2, lex.Colon);
1331        carryQ.cq[7] = carryout2carry(pablo_blk_Advance(namespace_sep, carryQ.get_carry_in(7), local_part_start));
1332        local_part_err = simd_andc(local_part_start, lex.NameScan);
1333        carryQ.cq[8] = carryout2carry(pablo_blk_ScanThru(local_part_start, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(8), tempvar3));
1334        colon2_err = simd_and(tempvar3, lex.Colon);
1335        ncname_err = simd_and(ncname_stream, lex.Colon);
1336        if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err, local_part_err), colon2_err), ncname_err))) {
1337          assert_0_error("name syntax error", simd_or(simd_or(simd_or(void_prefix_err, local_part_err), colon2_err), ncname_err));
1338        }
1339        check_streams.non_ascii_name_starts = simd_andc(name_start, lex.ASCII_name_start);
1340        check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream, name_start), lex.ASCII_name_char), u8.suffix);
1341        carryQ.CarryQ_Adjust(9);
1342  }
1343  IDISA_INLINE void clear() {
1344 }
1345  void do_final_block(CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Tag_Callouts & tag_Callouts, Lex & lex, U8 & u8, Check_streams & check_streams, BitBlock EOF_mask) {
1346                BitBlock PI_names, GenRefs, ElemNames, AttNames, qname_stream, ncname_stream;
1347                BitBlock name_stream, name_start, name_cursor, void_prefix_err, namespace_sep;
1348                BitBlock local_part_start, local_part_err, colon2_err, ncname_err;
1349
1350                BitBlock tempvar0, tempvar1, tempvar2, tempvar3;
1351
1352
1353        carryQ.cq[0] = carryout2carry(pablo_blk_SpanUpTo(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carryQ.get_carry_in(0), PI_names));
1354        carryQ.cq[1] = carryout2carry(pablo_blk_SpanUpTo(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carryQ.get_carry_in(1), GenRefs));
1355        carryQ.cq[2] = carryout2carry(pablo_blk_SpanUpTo(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carryQ.get_carry_in(2), ElemNames));
1356        carryQ.cq[3] = carryout2carry(pablo_blk_SpanUpTo(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carryQ.get_carry_in(3), AttNames));
1357        qname_stream = simd_or(ElemNames, AttNames);
1358        ncname_stream = simd_or(PI_names, GenRefs);
1359        name_stream = simd_or(qname_stream, ncname_stream);
1360        carryQ.cq[4] = carryout2carry(pablo_blk_Advance(name_stream, carryQ.get_carry_in(4), tempvar0));
1361        name_start = simd_andc(name_stream, tempvar0);
1362        carryQ.cq[5] = carryout2carry(pablo_blk_Advance(name_stream, carryQ.get_carry_in(5), tempvar1));
1363        name_cursor = simd_andc(name_stream, tempvar1);
1364        void_prefix_err = simd_and(name_cursor, lex.Colon);
1365        carryQ.cq[6] = carryout2carry(pablo_blk_ScanThru(name_cursor, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(6), tempvar2));
1366        namespace_sep = simd_and(tempvar2, lex.Colon);
1367        carryQ.cq[7] = carryout2carry(pablo_blk_Advance(namespace_sep, carryQ.get_carry_in(7), local_part_start));
1368        local_part_err = simd_andc(local_part_start, lex.NameScan);
1369        carryQ.cq[8] = carryout2carry(pablo_blk_ScanThru(local_part_start, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(8), tempvar3));
1370        colon2_err = simd_and(tempvar3, lex.Colon);
1371        ncname_err = simd_and(ncname_stream, lex.Colon);
1372        if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err, local_part_err), colon2_err), ncname_err))) {
1373          assert_0_error("name syntax error", simd_or(simd_or(simd_or(void_prefix_err, local_part_err), colon2_err), ncname_err));
1374        }
1375        check_streams.non_ascii_name_starts = simd_andc(name_start, lex.ASCII_name_start);
1376        check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream, name_start), lex.ASCII_name_char), u8.suffix);
1377  }
1378  CarryArray<9, 0> carryQ;
1379  };
1380
1381
1382
1383//////////////////////////////////////////////////////////////////////////////////////////
1384// Headers that depend @ global stream struct types.
1385//////////////////////////////////////////////////////////////////////////////////////////
1386#include <simd-lib/transpose.hpp>
1387#include <post_process.hpp>
1388
1389static void do_process(FILE *infile, FILE *outfile);
1390
1391int main(int argc, char * argv[]) {
1392
1393        char * infilename, * outfilename;
1394        FILE *infile, *outfile;
1395        struct stat fileinfo;
1396
1397        if (argc < 2) {
1398                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
1399                exit(-1);
1400        }
1401
1402        infilename = argv[1];
1403        stat(infilename, &fileinfo);
1404        infile = fopen(infilename, "rb");
1405        if (!infile) {
1406                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
1407                exit(-1);
1408        }
1409
1410        if (argc < 3) outfile = stdout;
1411        else {
1412                outfilename = argv[2];
1413                outfile = fopen(outfilename, "wb");
1414                if (!outfile) {
1415                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
1416                        exit(-1);
1417                }
1418        }
1419
1420        //PERF_SEC_BIND(1);
1421
1422        PERF_SEC_INIT(parser_timer);
1423
1424        do_process(infile, outfile);
1425
1426        PERF_SEC_DUMP(parser_timer);
1427
1428        PERF_SEC_DESTROY(parser_timer);
1429
1430        fclose(infile);
1431        fclose(outfile);
1432
1433        return(0);
1434}
1435
1436
1437void do_process(FILE *infile, FILE *outfile) {
1438
1439      struct Basis_bits basis_bits;
1440
1441  struct U8 u8;
1442
1443  struct Lex lex;
1444
1445  struct Marker marker;
1446
1447  struct CtCDPI_Callouts ctCDPI_Callouts;
1448
1449  struct Ref_Callouts ref_Callouts;
1450
1451  struct Tag_Callouts tag_Callouts;
1452
1453  struct Check_streams check_streams;
1454
1455
1456
1457
1458    LineColTracker tracker;
1459                #ifndef STL_ALIGNED_VECTOR
1460                        TagMatcher<SEGMENT_SIZE,LOOKAHEAD_SIZE> matcher;
1461                #endif
1462
1463    int block_base  = 0;
1464                int block_pos   = 0;
1465    int buffer_base = 0;
1466    int buffer_pos  = 0;
1467    int chars_avail = 0;
1468                int chars_read  = 0;
1469    char * bytedata;
1470
1471    //////////////////////////////////////////////////////////////////////////////////////////
1472    // Buffer Management
1473    //////////////////////////////////////////////////////////////////////////////////////////
1474                //      BitBlock buf[(BUFFER_SIZE)/sizeof(BitBlock)];
1475                //      char_t * src_buffer = (char *)buf + COPYBACK_SIZE;
1476
1477                #ifdef STL_ALIGNED_VECTOR
1478                        std::vector<char, AAllocator<char> > src_buffer;
1479                        src_buffer.reserve(BUFFER_SIZE);
1480                #else
1481                        char * COPYBACK;
1482                        char * src_buffer;
1483                        ALLOC_STATIC_ALIGNED_BYTE_BUFFER_WITH_COPYBACK(COPYBACK, src_buffer);
1484                #endif
1485
1486    //////////////////////////////////////////////////////////////////////////////////////////
1487    // XML Validation / Content Model
1488    //////////////////////////////////////////////////////////////////////////////////////////
1489                chars_read = fread((void *)&src_buffer[0], 1, SEGMENT_SIZE, infile);
1490                chars_avail = chars_read;
1491                if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
1492
1493    if(chars_read<4){
1494                fprintf(stderr,"File is too short. Not well formed.\n");
1495                exit(-1);
1496    }
1497
1498    Entity_Info * e = new Entity_Info;
1499                e->AnalyzeSignature((unsigned char *)&src_buffer[0]);
1500
1501    if (e->code_unit_base == ASCII) {
1502
1503                XML_Decl_Parser<ASCII> decl_parser((unsigned char *)&src_buffer[0]);
1504
1505                decl_parser.ReadXMLInfo(*e);
1506
1507                if (e->code_unit_size != SingleByte || (e->has_encoding_decl && (!at_UTF_8(e->encoding)))){
1508                        fprintf(stderr,"Sorry, this xmlwf demo only works for UTF-8.\n");
1509                        exit(-1);
1510                }
1511    }
1512    else {
1513        fprintf(stderr,"Sorry, this xmlwf demo does not process EBCDIC.\n");
1514        exit(-1);
1515    }
1516
1517    if (e->content_start != 0) {
1518
1519                memmove(&src_buffer[0], &src_buffer[e->content_start], chars_avail - e->content_start);
1520                buffer_pos = e->content_start;
1521                if ((chars_avail-e->content_start) < SEGMENT_SIZE) {
1522                        chars_read = chars_avail - e->content_start + fread(&src_buffer[chars_avail-e->content_start], 1, e->content_start, infile);
1523                        chars_avail = chars_read;
1524                }
1525                if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
1526    }
1527
1528        //////////////////////////////////////////////////////////////////////////////////////////
1529        // Read OVERLAP bytes to support post processing validation lookahead.
1530        //////////////////////////////////////////////////////////////////////////////////////////
1531        chars_read = chars_avail + fread(&src_buffer[chars_avail], 1, LOOKAHEAD_SIZE, infile);
1532        chars_avail = chars_read;
1533        if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
1534
1535      Transpose transpose;
1536      Parse_refs parse_refs;
1537  Parse_tags parse_tags;
1538  Classify_bytes_Validate_utf8 classify_bytes_Validate_utf8;
1539  Parse_CtCDPI parse_CtCDPI;
1540  Do_check_streams do_check_streams;
1541  Validate_xml_names validate_xml_names;
1542
1543
1544    //////////////////////////////////////////////////////////////////////////////////////////
1545    // Full Segments
1546    //////////////////////////////////////////////////////////////////////////////////////////
1547        #ifndef STL_ALIGNED_VECTOR
1548        matcher.setSrc((char *)&src_buffer[0]);
1549        #endif
1550        while (chars_avail >= SEGMENT_SIZE) {
1551      PERF_SEC_START(parser_timer);
1552      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
1553          block_base = blk*BLOCK_SIZE;
1554                  //s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
1555          bytedata = &src_buffer[block_base];
1556
1557  transpose.do_block(bytedata, basis_bits);
1558  classify_bytes_Validate_utf8.do_block(basis_bits, lex, u8);
1559  parse_CtCDPI.do_block(bytedata, lex, marker, ctCDPI_Callouts, check_streams);
1560  parse_tags.do_block(lex, marker, tag_Callouts);
1561  parse_refs.do_block(lex, marker, ref_Callouts);
1562  validate_xml_names.do_block(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, check_streams);
1563  do_check_streams.do_block(marker, tag_Callouts, check_streams);
1564
1565          tracker.StoreNewlines(lex.LF);
1566                  postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
1567                                        #ifndef STL_ALIGNED_VECTOR
1568          matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
1569                                        #endif
1570          tracker.AdvanceBlock();
1571      }
1572                        #ifndef STL_ALIGNED_VECTOR
1573      matcher.StreamScan(chars_avail);
1574      matcher.Advance_buffer();
1575                        #endif
1576      PERF_SEC_END(parser_timer, chars_avail);
1577
1578          memmove(&src_buffer[0], &src_buffer[SEGMENT_SIZE], LOOKAHEAD_SIZE); // CopyBack Trailing Padding
1579
1580          chars_read = fread(&src_buffer[LOOKAHEAD_SIZE], 1, SEGMENT_SIZE, infile) + LOOKAHEAD_SIZE;
1581          chars_avail = chars_read;
1582          if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
1583          buffer_pos += chars_avail;
1584          buffer_base = buffer_pos;
1585    }
1586
1587    //////////////////////////////////////////////////////////////////////////////////////////
1588    // Final Partial Segment
1589    //////////////////////////////////////////////////////////////////////////////////////////
1590    PERF_SEC_START(parser_timer);
1591
1592    block_pos = 0;
1593    int remaining = chars_avail;
1594
1595    /* Full Blocks */
1596    while (remaining >= BLOCK_SIZE) {
1597          block_base = block_pos;
1598//                              s2p_do_block((BytePack *) &src_buffer[block_pos], basis_bits);
1599          bytedata = &src_buffer[block_base];
1600
1601  transpose.do_block(bytedata, basis_bits);
1602  classify_bytes_Validate_utf8.do_block(basis_bits, lex, u8);
1603  parse_CtCDPI.do_block(bytedata, lex, marker, ctCDPI_Callouts, check_streams);
1604  parse_tags.do_block(lex, marker, tag_Callouts);
1605  parse_refs.do_block(lex, marker, ref_Callouts);
1606  validate_xml_names.do_block(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, check_streams);
1607  do_check_streams.do_block(marker, tag_Callouts, check_streams);
1608          tracker.StoreNewlines(lex.LF);
1609                                postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
1610                                        #ifndef STL_ALIGNED_VECTOR
1611                                                matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
1612                                        #endif
1613          tracker.AdvanceBlock();
1614          block_pos += BLOCK_SIZE;
1615          remaining -= BLOCK_SIZE;
1616    }
1617    block_base = block_pos;
1618
1619//    Partial Block or Any Carry
1620//
1621//    Eliminating the @anycarry test simplifies dependencies. - RDC Nov. 6, 2012
1622//
1623#ifdef USE_ANY_CARRY_TEST
1624   if (remaining > 0 || parse_refs.carryQ.CarryTest(0, 6) || parse_tags.carryQ.CarryTest(0, 13) || classify_bytes_Validate_utf8.carryQ.CarryTest(0, 10) || parse_CtCDPI.carryQ.CarryTest(0, 19) || 0 || validate_xml_names.carryQ.CarryTest(0, 9)) {
1625#endif
1626          EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
1627//                              s2p_do_final_block((BytePack *) &src_buffer[block_pos], basis_bits, EOF_mask);
1628          bytedata = &src_buffer[block_pos];
1629
1630  transpose.do_final_block(bytedata, basis_bits, EOF_mask);
1631  classify_bytes_Validate_utf8.do_final_block(basis_bits, lex, u8, EOF_mask);
1632  parse_CtCDPI.do_final_block(bytedata, lex, marker, ctCDPI_Callouts, check_streams, EOF_mask);
1633  parse_tags.do_final_block(lex, marker, tag_Callouts, EOF_mask);
1634  parse_refs.do_final_block(lex, marker, ref_Callouts, EOF_mask);
1635  validate_xml_names.do_final_block(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, check_streams, EOF_mask);
1636  do_check_streams.do_final_block(marker, tag_Callouts, check_streams, EOF_mask);
1637          tracker.StoreNewlines(lex.LF);
1638                                postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
1639                                        #ifndef STL_ALIGNED_VECTOR
1640          matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
1641                                        #endif
1642          tracker.AdvanceBlock();
1643
1644#ifdef USE_ANY_CARRY_TEST
1645   }
1646#endif
1647
1648    buffer_pos += chars_avail;
1649    buffer_base = buffer_pos;
1650                #ifndef STL_ALIGNED_VECTOR
1651    matcher.StreamScan(chars_avail);
1652    matcher.Advance_buffer();
1653
1654    if (matcher.depth != 0) {
1655      fprintf(stderr, "tag matching error (depth %i) at position %i\n", matcher.depth, buffer_base);
1656      exit(-1);
1657    }
1658                #endif
1659                PERF_SEC_END(parser_timer, chars_avail);
1660}
1661
Note: See TracBrowser for help on using the repository browser.