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

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

micro benchmark with Agner's testp ready

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