source: proto/xmlschema/src/xmlwf.cpp @ 2234

Last change on this file since 2234 was 2234, checked in by shiyangy, 7 years ago
File size: 114.3 KB
Line 
1#include <stdio.h>
2#include <stdlib.h>
3#include <errno.h>
4#include <sys/types.h>
5#include <sys/stat.h>
6
7#define LocalCarryDeclare(name, count)\
8CarryArray<count, 0> name;\
9
10#include "../lib/bitblock.hpp"
11#include "../lib/carryQ.hpp"
12#include "../lib/bitstream_iterator.hpp"
13#include "../lib/bitblock_iterator.hpp"
14#include "../lib/s2p.hpp"
15#include "../lib/perflib/perfsec.h"
16
17#define VECTOR_WIDTH 8
18#define VECTOR_TYPE (char)
19#define DEBUG 0
20
21#define ScanBlock long long int
22
23
24#include <xmldecl.h>
25#include <namechars.h>
26#include <TagMatcher.hpp>
27#include <LineColTracker.hpp>
28#include <ErrorUtil.h>
29#include <ErrorTracker.h>
30#include <XMLTestSuiteError.h>
31
32#include "../symtab/pbgs_identity_symbol_table.h"
33#include "../lib/buffer.hpp"
34
35#define OVERLAP_BUFSIZE PADDING_SIZE //sizeof(BitBlock)
36
37// Define the mappings for pablo.assert_0(strm, errkind) statements which
38// compile to the the form assert_0_error(errkind, strm)
39#define assert_0_error(errkind, errstrm) error_tracker.NoteError(errkind, errstrm);
40
41#ifdef BUFFER_PROFILING
42    BOM_Table * parser_timer;
43#elif CODE_CLOCKER
44    //#define NUM_EVENTS 1
45    //int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
46    //int Events[NUM_EVENTS] = {PAPI_L2_DCM};
47    #define NUM_EVENTS 2
48    int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
49    int cal_size = 20;
50    CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
51#else
52    void * parser_timer;
53#endif
54
55
56int block_base=0;
57int buffer_base=0;
58char * source;
59int previous_block_last_elem_start;
60
61ErrorTracker error_tracker;
62BitBlock EOF_mask = simd<1>::constant<1>();
63
64BitBlock elem_starts;
65BytePack hashvalues[2];
66
67vector <int> gids;
68PBGSIdentitySymbolTable pbgs_symbol_table;
69
70stack <vector<char>* > elem_vec_stack;
71map<char, vector<char>* > elem_vec_map;
72map<char, vector<int>* > elem_pos_map;
73
74//file of all the gids
75FILE * ofile;
76
77//buffer for double_list data validation
78int val_buf_curser = 0;
79int content_start_pos = 0;
80int content_start_flag = 0; //-1 if the content_start is not in the current block, need to search for the comming blocks; 1 if content_start is in the former block; 0 content_start and content_end are both in current block
81int content_end_flag = 0; // content_end flag
82int val_buf_avail = sizeof(BitBlock)*8; // char available of val_buf
83//BytePack val_buf[(BUFFER_SIZE+BLOCK_SIZE+OVERLAP_BUFSIZE*2)/sizeof(BitBlock)];
84char val_buf[sizeof(BitBlock)*8];
85
86int counter = 0;
87
88static inline int ScanBackwardPos(BitBlock * block, int pos,int previous_block_last_elem_start);
89static inline int compute_hash_value (int lgth, int start);
90static inline char ElemEnd_grouping(int pos);
91//static inline int StreamScanLengthGrouping(ScanBlock * stream, ScanBlock * stream2, int blk_count);
92static inline int StreamScanLengthGrouping(Tag_Callouts & tag_Callouts, int blk_count);
93static inline void print_vecs();
94static inline void print_elem_vec(vector<char>* vec, int size);
95static inline void validation_do_block(Lex & lex, Tag_Callouts & tag_Callouts, Hash_data & hash_data, int chars_avail);
96static inline void print_basis_bits(Basis_bits & basis_bits);
97static inline void validate_city_gml();
98static inline void print_streams(char * s1,BitBlock & block, char * name);
99static inline void print_buffer(char * block, char * name);
100static inline void val_double_list(Tag_Callouts & tag_Callouts,int end_pos,int block_pos,int blk);
101static inline void val_dl_block();
102
103struct Citygml citygml;
104Validation_Vec_2 validation_Vec_2;
105
106//////////////////////////////////////////////////////////////////////////////////////////
107// Buffer Management // WARNING: Do Not update #defines. Results in TagMatcher errors.
108//////////////////////////////////////////////////////////////////////////////////////////
109#define PADDING_BLOCKS 0
110#define PADDING_SIZE (BLOCK_SIZE * PADDING_BLOCKS)
111#define COPYBACK_BLOCKS 2
112#define COPYBACK_SIZE (BLOCK_SIZE * COPYBACK_BLOCKS)
113#define LOOKAHEAD_BLOCKS 1
114#define LOOKAHEAD_SIZE (BLOCK_SIZE * LOOKAHEAD_BLOCKS)
115#define SEGMENT_BLOCKS  12 // WARNING: TagMatcher.hpp causes xmlconf test suite failures for SEGMENT_BLOCKS < 3.
116#define SEGMENT_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
117#define BUFFER_SIZE (COPYBACK_SIZE + SEGMENT_SIZE + LOOKAHEAD_SIZE + PADDING_SIZE)
118
119//////////////////////////////////////////////////////////////////////////////////////////
120// @ global depends on 'error_tracker' and 'EOF_mask' definitions.
121//////////////////////////////////////////////////////////////////////////////////////////
122  struct U8 {
123  BitBlock unibyte;
124  BitBlock prefix;
125  BitBlock prefix2;
126  BitBlock prefix3;
127  BitBlock prefix4;
128  BitBlock suffix;
129  BitBlock badprefix;
130  BitBlock xE0;
131  BitBlock xED;
132  BitBlock xF0;
133  BitBlock xF4;
134  BitBlock xA0_xBF;
135  BitBlock x80_x9F;
136  BitBlock x90_xBF;
137  BitBlock x80_x8F;
138  BitBlock xEF;
139  BitBlock xBF;
140  BitBlock xBE;
141  BitBlock scope22;
142  BitBlock scope32;
143  BitBlock scope33;
144  BitBlock scope42;
145  BitBlock scope43;
146  BitBlock scope44;
147  BitBlock xE0_scope;
148  BitBlock xED_scope;
149  BitBlock xF0_scope;
150  BitBlock xF4_scope;
151  BitBlock xEF_scope;
152};
153
154  struct Lex {
155  BitBlock CR;
156  BitBlock LF;
157  BitBlock HT;
158  BitBlock SP;
159  BitBlock CRLF;
160  BitBlock RefStart;
161  BitBlock Semicolon;
162  BitBlock Colon;
163  BitBlock LAngle;
164  BitBlock RAngle;
165  BitBlock LBracket;
166  BitBlock RBracket;
167  BitBlock Exclam;
168  BitBlock QMark;
169  BitBlock Hyphen;
170  BitBlock Equals;
171  BitBlock SQuote;
172  BitBlock DQuote;
173  BitBlock Slash;
174  BitBlock Hash;
175  BitBlock x;
176  BitBlock ASCII_name_start;
177  BitBlock ASCII_name_char;
178  BitBlock NameScan;
179  BitBlock Digit;
180  BitBlock Hex;
181  BitBlock WS;
182};
183
184  struct Scope1 {
185  BitBlock RefStart;
186  BitBlock LAngle;
187  BitBlock Hyphen;
188  BitBlock QMark;
189  BitBlock RBracket;
190};
191
192  struct CtCDPI_Callouts {
193  BitBlock CD_end;
194  BitBlock Ct_starts;
195  BitBlock Ct_ends;
196  BitBlock CD_starts;
197  BitBlock CD_ends;
198  BitBlock PI_starts;
199  BitBlock PI_name_starts;
200  BitBlock PI_name_ends;
201  BitBlock PI_ends;
202  BitBlock CtCDPI_mask;
203};
204
205  struct Ref_Callouts {
206  BitBlock GenRef_starts;
207  BitBlock GenRef_ends;
208  BitBlock DecRef_starts;
209  BitBlock DecRef_ends;
210  BitBlock HexRef_starts;
211  BitBlock HexRef_ends;
212};
213
214  struct Hash_data {
215  BitBlock Hash_value;
216};
217
218  struct Tag_Callouts {
219  BitBlock ElemName_starts;
220  BitBlock ElemName_ends;
221  BitBlock ElemName_ends_1;
222  BitBlock ElemName_ends_2;
223  BitBlock ElemName_ends_3;
224  BitBlock ElemName_ends_4;
225  BitBlock ElemName_ends_5;
226  BitBlock ElemName_ends_6;
227  BitBlock ElemName_ends_7;
228  BitBlock ElemName_ends_8;
229  BitBlock ElemName_ends_9;
230  BitBlock ElemName_ends_10;
231  BitBlock ElemName_ends_11;
232  BitBlock ElemName_ends_12;
233  BitBlock ElemName_ends_13;
234  BitBlock ElemName_ends_14;
235  BitBlock ElemName_ends_15;
236  BitBlock ElemName_ends_16;
237  BitBlock ElemName_ends_17_and_longer;
238  BitBlock AttName_starts;
239  BitBlock AttName_ends;
240  BitBlock AttVal_starts;
241  BitBlock AttVal_ends;
242  BitBlock AttVal_spans;
243  BitBlock EmptyTag_marks;
244  BitBlock EndTag_marks;
245  BitBlock ElemName_starts_no_ns;
246  BitBlock Tag_closing;
247  BitBlock ElemContent_starts;
248  BitBlock ElemContent_ends;
249  BitBlock stends;
250};
251
252  struct Basis_bits {
253  BitBlock bit_0;
254  BitBlock bit_1;
255  BitBlock bit_2;
256  BitBlock bit_3;
257  BitBlock bit_4;
258  BitBlock bit_5;
259  BitBlock bit_6;
260  BitBlock bit_7;
261};
262
263  struct Check_streams {
264  BitBlock misc_mask;
265  BitBlock non_ascii_name_starts;
266  BitBlock non_ascii_names;
267  BitBlock tag_marks;
268  BitBlock name_follows;
269  BitBlock att_refs;
270};
271
272  struct Xml_names {
273  BitBlock namespace_error;
274};
275
276  struct Citygml {
277  BitBlock null;
278  BitBlock appearanceMember;
279  BitBlock Appearance;
280  BitBlock surfaceDataMember;
281  BitBlock ParameterizedTexture;
282  BitBlock imageURI;
283  BitBlock textureType;
284  BitBlock wrapMode;
285  BitBlock borderColor;
286  BitBlock target;
287  BitBlock TexCoordList;
288  BitBlock textureCoordinates;
289};
290
291  struct Parse_refs {
292  Parse_refs() { 
293 }
294  IDISA_INLINE void do_block(Lex & lex, Scope1 & scope1, CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts) {
295                BitBlock ref_error, Ref1, NumRef2, NumRef3, HexRef3, ref_error1, ref_error2;
296                BitBlock ref_ends, ref_error3;
297
298
299        ref_Callouts.GenRef_starts = simd<1>::constant<0>();
300        ref_Callouts.GenRef_ends = simd<1>::constant<0>();
301        ref_Callouts.DecRef_starts = simd<1>::constant<0>();
302        ref_Callouts.DecRef_ends = simd<1>::constant<0>();
303        ref_Callouts.HexRef_starts = simd<1>::constant<0>();
304        ref_Callouts.HexRef_ends = simd<1>::constant<0>();
305        ref_error = simd<1>::constant<0>();
306        Ref1 = simd_andc(lex.RefStart, ctCDPI_Callouts.CtCDPI_mask);
307        if ((bitblock::any(Ref1) || carryQ.CarryTest(0, 6))) {
308          scope1.RefStart = carryQ.BitBlock_advance_ci_co(Ref1, carryQ.get_carry_in(0), 0);
309          NumRef2 = simd_and(scope1.RefStart, lex.Hash);
310          ref_Callouts.GenRef_starts = simd_andc(scope1.RefStart, lex.Hash);
311          NumRef3 = carryQ.BitBlock_advance_ci_co(NumRef2, carryQ.get_carry_in(1), 1);
312          HexRef3 = simd_and(NumRef3, lex.x);
313          ref_Callouts.DecRef_starts = simd_andc(NumRef3, lex.x);
314          ref_Callouts.HexRef_starts = carryQ.BitBlock_advance_ci_co(HexRef3, carryQ.get_carry_in(2), 2);
315          ref_Callouts.GenRef_ends = carryQ.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts, lex.NameScan, carryQ.get_carry_in(3), 3);
316          ref_Callouts.DecRef_ends = carryQ.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carryQ.get_carry_in(4), 4);
317          ref_Callouts.HexRef_ends = carryQ.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carryQ.get_carry_in(5), 5);
318          ref_error1 = simd_andc(ref_Callouts.DecRef_starts, lex.Digit);
319          ref_error2 = simd_andc(ref_Callouts.HexRef_starts, lex.Hex);
320          ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
321          ref_error3 = simd_andc(ref_ends, lex.Semicolon);
322          ref_error = simd_or(simd_or(ref_error1, ref_error2), ref_error3);
323          if (bitblock::any(ref_error)) {
324            error_tracker.NoteError("Reference error found", ref_error);
325          }
326        }
327        else {
328          carryQ.CarryDequeueEnqueue(0, 6);
329        }
330        carryQ.CarryQ_Adjust(6);
331  }
332  void do_final_block(Lex & lex, Scope1 & scope1, CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, BitBlock EOF_mask) {
333                BitBlock ref_error, Ref1, NumRef2, NumRef3, HexRef3, ref_error1, ref_error2;
334                BitBlock ref_ends, ref_error3;
335
336
337        ref_Callouts.GenRef_starts = simd<1>::constant<0>();
338        ref_Callouts.GenRef_ends = simd<1>::constant<0>();
339        ref_Callouts.DecRef_starts = simd<1>::constant<0>();
340        ref_Callouts.DecRef_ends = simd<1>::constant<0>();
341        ref_Callouts.HexRef_starts = simd<1>::constant<0>();
342        ref_Callouts.HexRef_ends = simd<1>::constant<0>();
343        ref_error = simd<1>::constant<0>();
344        Ref1 = simd_andc(lex.RefStart, ctCDPI_Callouts.CtCDPI_mask);
345        if ((bitblock::any(Ref1) || carryQ.CarryTest(0, 6))) {
346          scope1.RefStart = carryQ.BitBlock_advance_ci_co(Ref1, carryQ.get_carry_in(0), 0);
347          NumRef2 = simd_and(scope1.RefStart, lex.Hash);
348          ref_Callouts.GenRef_starts = simd_andc(scope1.RefStart, lex.Hash);
349          NumRef3 = carryQ.BitBlock_advance_ci_co(NumRef2, carryQ.get_carry_in(1), 1);
350          HexRef3 = simd_and(NumRef3, lex.x);
351          ref_Callouts.DecRef_starts = simd_andc(NumRef3, lex.x);
352          ref_Callouts.HexRef_starts = carryQ.BitBlock_advance_ci_co(HexRef3, carryQ.get_carry_in(2), 2);
353          ref_Callouts.GenRef_ends = carryQ.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts, lex.NameScan, carryQ.get_carry_in(3), 3);
354          ref_Callouts.DecRef_ends = carryQ.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carryQ.get_carry_in(4), 4);
355          ref_Callouts.HexRef_ends = carryQ.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carryQ.get_carry_in(5), 5);
356          ref_error1 = simd_andc(ref_Callouts.DecRef_starts, lex.Digit);
357          ref_error2 = simd_andc(ref_Callouts.HexRef_starts, lex.Hex);
358          ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
359          ref_error3 = simd_andc(ref_ends, lex.Semicolon);
360          ref_error = simd_or(simd_or(ref_error1, ref_error2), ref_error3);
361          if (bitblock::any(ref_error)) {
362            error_tracker.NoteError("Reference error found", ref_error);
363          }
364        }
365        else {
366          carryQ.CarryDequeueEnqueue(0, 6);
367        }
368  }
369  void do_segment(Lex lex[], Scope1 scope1[], CtCDPI_Callouts ctCDPI_Callouts[], Ref_Callouts ref_Callouts[], int segment_blocks) {
370  int i;
371  for (i = 0; i < segment_blocks; i++)
372    do_block(lex[i], scope1[i], ctCDPI_Callouts[i], ref_Callouts[i]);
373  }
374  CarryArray<6> carryQ;
375  };
376
377  struct Parse_tags {
378  Parse_tags() { 
379 }
380  IDISA_INLINE void do_block(Lex & lex, Scope1 & scope1, CtCDPI_Callouts & ctCDPI_Callouts, Tag_Callouts & tag_Callouts) {
381                BitBlock DQuoteDelim, SQuoteDelim, AttListDelim, LAngleFollow, ColonInElemName;
382                BitBlock ParseError, EqToCheck, AttValEnds, AfterWS, AttListEnd, AttNameStart;
383                BitBlock AttNameFollow, EqExpected, AttValPos, DQuoteAttVal, SQuoteAttVal;
384                BitBlock DQuoteAttEnd, SQuoteAttEnd, AttValEnd, AttValFollow, STagEnds;
385                BitBlock advanced, none_emptyelem_con_start, scanfrom, scan_to, EndTagEnds;
386
387
388        DQuoteDelim = simd_or(lex.DQuote, lex.LAngle);
389        SQuoteDelim = simd_or(lex.SQuote, lex.LAngle);
390        AttListDelim = simd_or(lex.Slash, lex.RAngle);
391        LAngleFollow = simd_andc(scope1.LAngle, ctCDPI_Callouts.CtCDPI_mask);
392        tag_Callouts.ElemName_starts = simd_andc(LAngleFollow, lex.Slash);
393        tag_Callouts.EndTag_marks = simd_and(LAngleFollow, lex.Slash);
394        ColonInElemName = simd_and(lex.Colon, lex.NameScan);
395        tag_Callouts.ElemName_starts_no_ns = simd_or(carryQ.BitBlock_advance_ci_co(ColonInElemName, carryQ.get_carry_in(0), 0), tag_Callouts.ElemName_starts);
396        tag_Callouts.ElemName_ends = carryQ.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts, lex.NameScan, carryQ.get_carry_in(1), 1);
397        ParseError = simd_and(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
398        tag_Callouts.AttName_starts = simd<1>::constant<0>();
399        tag_Callouts.AttName_ends = simd<1>::constant<0>();
400        EqToCheck = simd<1>::constant<0>();
401        tag_Callouts.AttVal_starts = simd<1>::constant<0>();
402        AttValEnds = simd<1>::constant<0>();
403        tag_Callouts.AttVal_ends = simd<1>::constant<0>();
404        AfterWS = carryQ.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends, lex.WS, carryQ.get_carry_in(2), 2);
405        AttListEnd = simd_and(AfterWS, AttListDelim);
406        AttNameStart = simd_andc(AfterWS, AttListDelim);
407        ParseError = simd_or(ParseError, simd_and(tag_Callouts.ElemName_ends, AttNameStart));
408        if ((bitblock::any(AttNameStart) || carryQ.CarryTest(3, 8))) {
409          tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
410          AttNameFollow = carryQ.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, carryQ.get_carry_in(3), 3);
411          tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
412          if ((bitblock::any(simd_and(AttNameFollow, lex.WS)) || carryQ.CarryTest(4, 1))) {
413            EqExpected = carryQ.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, carryQ.get_carry_in(4), 4);
414          }
415          else {
416            EqExpected = AttNameFollow;
417            carryQ.CarryDequeueEnqueue(4, 1);
418          }
419          EqToCheck = simd_or(EqToCheck, EqExpected);
420          AttValPos = carryQ.BitBlock_scanthru_ci_co(EqExpected, simd_or(EqExpected, lex.WS), carryQ.get_carry_in(5), 5);
421          tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
422          DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
423          SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
424          DQuoteAttEnd = carryQ.BitBlock_scanthru_ci_co(DQuoteAttVal, simd_not(simd_andc(DQuoteDelim, DQuoteAttVal)), carryQ.get_carry_in(6), 6);
425          SQuoteAttEnd = carryQ.BitBlock_scanthru_ci_co(SQuoteAttVal, simd_not(simd_andc(SQuoteDelim, SQuoteAttVal)), carryQ.get_carry_in(7), 7);
426          AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
427          AttValEnds = simd_or(AttValEnds, AttValEnd);
428          AttValFollow = carryQ.BitBlock_advance_ci_co(AttValEnd, carryQ.get_carry_in(8), 8);
429          tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
430          if ((bitblock::any(simd_and(AttValFollow, lex.WS)) || carryQ.CarryTest(9, 1))) {
431            AfterWS = carryQ.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, carryQ.get_carry_in(9), 9);
432          }
433          else {
434            AfterWS = AttValFollow;
435            carryQ.CarryDequeueEnqueue(9, 1);
436          }
437          AfterWS = carryQ.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, carryQ.get_carry_in(10), 10);
438          AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
439          AttNameStart = simd_andc(AfterWS, AttListDelim);
440          while (bitblock::any(AttNameStart)) {
441            LocalCarryDeclare(subcarryQ, 8);
442            tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
443            AttNameFollow = subcarryQ.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, simd<1>::constant<0>(), 0);
444            tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
445            if (bitblock::any(simd_and(AttNameFollow, lex.WS))) {
446              EqExpected = subcarryQ.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, simd<1>::constant<0>(), 1);
447            }
448            else {
449              EqExpected = AttNameFollow;
450            }
451            EqToCheck = simd_or(EqToCheck, EqExpected);
452            AttValPos = subcarryQ.BitBlock_scanthru_ci_co(EqExpected, simd_or(EqExpected, lex.WS), simd<1>::constant<0>(), 2);
453            tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
454            DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
455            SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
456            DQuoteAttEnd = subcarryQ.BitBlock_scanthru_ci_co(DQuoteAttVal, simd_not(simd_andc(DQuoteDelim, DQuoteAttVal)), simd<1>::constant<0>(), 3);
457            SQuoteAttEnd = subcarryQ.BitBlock_scanthru_ci_co(SQuoteAttVal, simd_not(simd_andc(SQuoteDelim, SQuoteAttVal)), simd<1>::constant<0>(), 4);
458            AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
459            AttValEnds = simd_or(AttValEnds, AttValEnd);
460            AttValFollow = subcarryQ.BitBlock_advance_ci_co(AttValEnd, simd<1>::constant<0>(), 5);
461            tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
462            if (bitblock::any(simd_and(AttValFollow, lex.WS))) {
463              AfterWS = subcarryQ.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, simd<1>::constant<0>(), 6);
464            }
465            else {
466              AfterWS = AttValFollow;
467            }
468            AfterWS = subcarryQ.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, simd<1>::constant<0>(), 7);
469            AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
470            AttNameStart = simd_andc(AfterWS, AttListDelim);
471            carryQ.CarryCombine((ICarryQueue *) &subcarryQ, 3, 8);
472          }
473        }
474        else {
475          carryQ.CarryDequeueEnqueue(3, 8);
476        }
477        STagEnds = simd_and(AttListEnd, lex.RAngle);
478        tag_Callouts.EmptyTag_marks = carryQ.BitBlock_advance_ci_co(simd_and(AttListEnd, lex.Slash), carryQ.get_carry_in(11), 11);
479        tag_Callouts.Tag_closing = simd_or(tag_Callouts.EmptyTag_marks, tag_Callouts.EndTag_marks);
480        ParseError = simd_or(ParseError, simd_and(tag_Callouts.AttVal_ends, tag_Callouts.AttName_starts));
481        ParseError = simd_or(ParseError, simd_and(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends));
482        ParseError = simd_or(ParseError, simd_andc(EqToCheck, lex.Equals));
483        ParseError = simd_or(ParseError, simd_andc(tag_Callouts.AttVal_starts, simd_or(lex.DQuote, lex.SQuote)));
484        ParseError = simd_or(ParseError, simd_andc(AttValEnds, simd_or(lex.DQuote, lex.SQuote)));
485        ParseError = simd_or(ParseError, simd_andc(tag_Callouts.EmptyTag_marks, lex.RAngle));
486        advanced = carryQ.BitBlock_advance_ci_co(STagEnds, carryQ.get_carry_in(12), 12);
487        tag_Callouts.stends = STagEnds;
488        none_emptyelem_con_start = carryQ.BitBlock_scanthru_ci_co(STagEnds, lex.WS, carryQ.get_carry_in(13), 13);
489        tag_Callouts.ElemContent_starts = simd_andc(simd_andc(simd_andc(carryQ.BitBlock_advance_ci_co(none_emptyelem_con_start, carryQ.get_carry_in(14), 14), lex.LAngle), lex.CR), lex.LF);
490        scanfrom = tag_Callouts.ElemContent_starts;
491        scan_to = lex.LAngle;
492        tag_Callouts.ElemContent_ends = carryQ.BitBlock_scanthru_ci_co(scanfrom, simd_not(scan_to), carryQ.get_carry_in(15), 15);
493        EndTagEnds = carryQ.BitBlock_scanthru_ci_co(tag_Callouts.EndTag_marks, simd_or(tag_Callouts.EndTag_marks, lex.NameScan), carryQ.get_carry_in(16), 16);
494        if ((bitblock::any(simd_and(EndTagEnds, lex.WS)) || carryQ.CarryTest(17, 1))) {
495          EndTagEnds = carryQ.BitBlock_scanthru_ci_co(EndTagEnds, lex.WS, carryQ.get_carry_in(17), 17);
496        }
497        else {
498          carryQ.CarryDequeueEnqueue(17, 1);
499        }
500        ParseError = simd_or(ParseError, simd_andc(EndTagEnds, lex.RAngle));
501        if (bitblock::any(ParseError)) {
502          error_tracker.NoteError("Tag parsing error found", ParseError);
503        }
504        tag_Callouts.AttVal_spans = carryQ.BitBlock_sub_ci_co(tag_Callouts.AttVal_ends, tag_Callouts.AttVal_starts, carryQ.get_carry_in(18), 18);
505        carryQ.CarryQ_Adjust(19);
506  }
507  void do_final_block(Lex & lex, Scope1 & scope1, CtCDPI_Callouts & ctCDPI_Callouts, Tag_Callouts & tag_Callouts, BitBlock EOF_mask) {
508                BitBlock DQuoteDelim, SQuoteDelim, AttListDelim, LAngleFollow, ColonInElemName;
509                BitBlock ParseError, EqToCheck, AttValEnds, AfterWS, AttListEnd, AttNameStart;
510                BitBlock AttNameFollow, EqExpected, AttValPos, DQuoteAttVal, SQuoteAttVal;
511                BitBlock DQuoteAttEnd, SQuoteAttEnd, AttValEnd, AttValFollow, STagEnds;
512                BitBlock advanced, none_emptyelem_con_start, scanfrom, scan_to, EndTagEnds;
513
514
515        DQuoteDelim = simd_or(lex.DQuote, lex.LAngle);
516        SQuoteDelim = simd_or(lex.SQuote, lex.LAngle);
517        AttListDelim = simd_or(lex.Slash, lex.RAngle);
518        LAngleFollow = simd_andc(scope1.LAngle, ctCDPI_Callouts.CtCDPI_mask);
519        tag_Callouts.ElemName_starts = simd_andc(LAngleFollow, lex.Slash);
520        tag_Callouts.EndTag_marks = simd_and(LAngleFollow, lex.Slash);
521        ColonInElemName = simd_and(lex.Colon, lex.NameScan);
522        tag_Callouts.ElemName_starts_no_ns = simd_or(carryQ.BitBlock_advance_ci_co(ColonInElemName, carryQ.get_carry_in(0), 0), tag_Callouts.ElemName_starts);
523        tag_Callouts.ElemName_ends = carryQ.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts, lex.NameScan, carryQ.get_carry_in(1), 1);
524        ParseError = simd_and(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
525        tag_Callouts.AttName_starts = simd<1>::constant<0>();
526        tag_Callouts.AttName_ends = simd<1>::constant<0>();
527        EqToCheck = simd<1>::constant<0>();
528        tag_Callouts.AttVal_starts = simd<1>::constant<0>();
529        AttValEnds = simd<1>::constant<0>();
530        tag_Callouts.AttVal_ends = simd<1>::constant<0>();
531        AfterWS = carryQ.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends, lex.WS, carryQ.get_carry_in(2), 2);
532        AttListEnd = simd_and(AfterWS, AttListDelim);
533        AttNameStart = simd_andc(AfterWS, AttListDelim);
534        ParseError = simd_or(ParseError, simd_and(tag_Callouts.ElemName_ends, AttNameStart));
535        if ((bitblock::any(simd_and(AttNameStart, EOF_mask)) || carryQ.CarryTest(3, 8))) {
536          tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
537          AttNameFollow = carryQ.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, carryQ.get_carry_in(3), 3);
538          tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
539          if ((bitblock::any(simd_and(AttNameFollow, lex.WS)) || carryQ.CarryTest(4, 1))) {
540            EqExpected = carryQ.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, carryQ.get_carry_in(4), 4);
541          }
542          else {
543            EqExpected = AttNameFollow;
544            carryQ.CarryDequeueEnqueue(4, 1);
545          }
546          EqToCheck = simd_or(EqToCheck, EqExpected);
547          AttValPos = carryQ.BitBlock_scanthru_ci_co(EqExpected, simd_or(EqExpected, lex.WS), carryQ.get_carry_in(5), 5);
548          tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
549          DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
550          SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
551          DQuoteAttEnd = carryQ.BitBlock_scanthru_ci_co(DQuoteAttVal, simd_andc(EOF_mask, simd_andc(DQuoteDelim, DQuoteAttVal)), carryQ.get_carry_in(6), 6);
552          SQuoteAttEnd = carryQ.BitBlock_scanthru_ci_co(SQuoteAttVal, simd_andc(EOF_mask, simd_andc(SQuoteDelim, SQuoteAttVal)), carryQ.get_carry_in(7), 7);
553          AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
554          AttValEnds = simd_or(AttValEnds, AttValEnd);
555          AttValFollow = carryQ.BitBlock_advance_ci_co(AttValEnd, carryQ.get_carry_in(8), 8);
556          tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
557          if ((bitblock::any(simd_and(AttValFollow, lex.WS)) || carryQ.CarryTest(9, 1))) {
558            AfterWS = carryQ.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, carryQ.get_carry_in(9), 9);
559          }
560          else {
561            AfterWS = AttValFollow;
562            carryQ.CarryDequeueEnqueue(9, 1);
563          }
564          AfterWS = carryQ.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, carryQ.get_carry_in(10), 10);
565          AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
566          AttNameStart = simd_andc(AfterWS, AttListDelim);
567          while (bitblock::any(simd_and(AttNameStart, EOF_mask))) {
568            LocalCarryDeclare(subcarryQ, 8);
569            tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
570            AttNameFollow = subcarryQ.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, simd<1>::constant<0>(), 0);
571            tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
572            if (bitblock::any(simd_and(AttNameFollow, lex.WS))) {
573              EqExpected = subcarryQ.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, simd<1>::constant<0>(), 1);
574            }
575            else {
576              EqExpected = AttNameFollow;
577            }
578            EqToCheck = simd_or(EqToCheck, EqExpected);
579            AttValPos = subcarryQ.BitBlock_scanthru_ci_co(EqExpected, simd_or(EqExpected, lex.WS), simd<1>::constant<0>(), 2);
580            tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
581            DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
582            SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
583            DQuoteAttEnd = subcarryQ.BitBlock_scanthru_ci_co(DQuoteAttVal, simd_andc(EOF_mask, simd_andc(DQuoteDelim, DQuoteAttVal)), simd<1>::constant<0>(), 3);
584            SQuoteAttEnd = subcarryQ.BitBlock_scanthru_ci_co(SQuoteAttVal, simd_andc(EOF_mask, simd_andc(SQuoteDelim, SQuoteAttVal)), simd<1>::constant<0>(), 4);
585            AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
586            AttValEnds = simd_or(AttValEnds, AttValEnd);
587            AttValFollow = subcarryQ.BitBlock_advance_ci_co(AttValEnd, simd<1>::constant<0>(), 5);
588            tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
589            if (bitblock::any(simd_and(AttValFollow, lex.WS))) {
590              AfterWS = subcarryQ.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, simd<1>::constant<0>(), 6);
591            }
592            else {
593              AfterWS = AttValFollow;
594            }
595            AfterWS = subcarryQ.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, simd<1>::constant<0>(), 7);
596            AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
597            AttNameStart = simd_andc(AfterWS, AttListDelim);
598            carryQ.CarryCombine((ICarryQueue *) &subcarryQ, 3, 8);
599          }
600        }
601        else {
602          carryQ.CarryDequeueEnqueue(3, 8);
603        }
604        STagEnds = simd_and(AttListEnd, lex.RAngle);
605        tag_Callouts.EmptyTag_marks = carryQ.BitBlock_advance_ci_co(simd_and(AttListEnd, lex.Slash), carryQ.get_carry_in(11), 11);
606        tag_Callouts.Tag_closing = simd_or(tag_Callouts.EmptyTag_marks, tag_Callouts.EndTag_marks);
607        ParseError = simd_or(ParseError, simd_and(tag_Callouts.AttVal_ends, tag_Callouts.AttName_starts));
608        ParseError = simd_or(ParseError, simd_and(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends));
609        ParseError = simd_or(ParseError, simd_andc(EqToCheck, lex.Equals));
610        ParseError = simd_or(ParseError, simd_andc(tag_Callouts.AttVal_starts, simd_or(lex.DQuote, lex.SQuote)));
611        ParseError = simd_or(ParseError, simd_andc(AttValEnds, simd_or(lex.DQuote, lex.SQuote)));
612        ParseError = simd_or(ParseError, simd_andc(tag_Callouts.EmptyTag_marks, lex.RAngle));
613        advanced = carryQ.BitBlock_advance_ci_co(STagEnds, carryQ.get_carry_in(12), 12);
614        tag_Callouts.stends = STagEnds;
615        none_emptyelem_con_start = carryQ.BitBlock_scanthru_ci_co(STagEnds, lex.WS, carryQ.get_carry_in(13), 13);
616        tag_Callouts.ElemContent_starts = simd_andc(simd_andc(simd_andc(carryQ.BitBlock_advance_ci_co(none_emptyelem_con_start, carryQ.get_carry_in(14), 14), lex.LAngle), lex.CR), lex.LF);
617        scanfrom = tag_Callouts.ElemContent_starts;
618        scan_to = lex.LAngle;
619        tag_Callouts.ElemContent_ends = carryQ.BitBlock_scanthru_ci_co(scanfrom, simd_andc(EOF_mask, scan_to), carryQ.get_carry_in(15), 15);
620        EndTagEnds = carryQ.BitBlock_scanthru_ci_co(tag_Callouts.EndTag_marks, simd_or(tag_Callouts.EndTag_marks, lex.NameScan), carryQ.get_carry_in(16), 16);
621        if ((bitblock::any(simd_and(EndTagEnds, lex.WS)) || carryQ.CarryTest(17, 1))) {
622          EndTagEnds = carryQ.BitBlock_scanthru_ci_co(EndTagEnds, lex.WS, carryQ.get_carry_in(17), 17);
623        }
624        else {
625          carryQ.CarryDequeueEnqueue(17, 1);
626        }
627        ParseError = simd_or(ParseError, simd_andc(EndTagEnds, lex.RAngle));
628        if (bitblock::any(ParseError)) {
629          error_tracker.NoteError("Tag parsing error found", ParseError);
630        }
631        tag_Callouts.AttVal_spans = carryQ.BitBlock_sub_ci_co(tag_Callouts.AttVal_ends, tag_Callouts.AttVal_starts, carryQ.get_carry_in(18), 18);
632  }
633  void do_segment(Lex lex[], Scope1 scope1[], CtCDPI_Callouts ctCDPI_Callouts[], Tag_Callouts tag_Callouts[], int segment_blocks) {
634  int i;
635  for (i = 0; i < segment_blocks; i++)
636    do_block(lex[i], scope1[i], ctCDPI_Callouts[i], tag_Callouts[i]);
637  }
638  CarryArray<19> carryQ;
639  };
640
641  struct Classify_bytes_Validate_utf8 {
642  Classify_bytes_Validate_utf8() { 
643 }
644  IDISA_INLINE void do_block(Basis_bits & basis_bits, Lex & lex, U8 & u8) {
645                BitBlock temp1, temp2, temp3, temp4, temp5, temp6, temp7, temp8, temp9, temp10;
646                BitBlock temp11, temp12, temp13, temp14, temp15, temp16, temp17, temp18;
647                BitBlock temp19, temp20, temp21, temp22, temp23, temp24, temp25, temp26;
648                BitBlock temp27, temp28, temp29, temp30, temp31, temp32, temp33, temp34;
649                BitBlock temp35, temp36, temp37, temp38, temp39, temp40, temp41, temp42;
650                BitBlock temp43, temp44, temp45, temp46, temp47, temp48, x00_x1F, temp49;
651                BitBlock temp50, temp51, temp52, temp53, temp54, temp55, temp56, temp57;
652                BitBlock temp58, temp59, temp60, temp61, temp62, temp63, temp64, temp65;
653                BitBlock lex_error, u8_error, u8_FFFE_FFFF, u8anyscope, temp66, temp67, temp68;
654                BitBlock temp69, temp70, temp71, xE0, xED, xF0, temp72, xF4, xEF, temp73;
655                BitBlock u8lastscope, u8error1, u8error2, u8error3, u8error4, EF_BF_pending;
656                BitBlock u8mismatch;
657
658
659        temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
660        temp2 = simd_andc(basis_bits.bit_2, basis_bits.bit_3);
661        temp3 = simd_andc(temp2, temp1);
662        temp4 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
663        temp5 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
664        temp6 = simd_and(temp4, temp5);
665        lex.RefStart = simd_and(temp3, temp6);
666        temp7 = simd_and(basis_bits.bit_2, basis_bits.bit_3);
667        temp8 = simd_andc(temp7, temp1);
668        temp9 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
669        temp10 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
670        temp11 = simd_and(temp9, temp10);
671        lex.Semicolon = simd_and(temp8, temp11);
672        temp12 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
673        temp13 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
674        temp14 = simd_andc(temp12, temp13);
675        lex.LAngle = simd_and(temp8, temp14);
676        temp15 = simd_and(temp12, temp5);
677        lex.RAngle = simd_and(temp8, temp15);
678        temp16 = simd_andc(basis_bits.bit_1, basis_bits.bit_0);
679        temp17 = simd_andc(basis_bits.bit_3, basis_bits.bit_2);
680        temp18 = simd_and(temp16, temp17);
681        lex.LBracket = simd_and(temp18, temp11);
682        temp19 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
683        temp20 = simd_and(temp12, temp19);
684        lex.RBracket = simd_and(temp18, temp20);
685        temp21 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
686        temp22 = simd_andc(temp19, temp21);
687        lex.Exclam = simd_and(temp3, temp22);
688        temp23 = simd_and(temp12, temp10);
689        lex.QMark = simd_and(temp8, temp23);
690        lex.Hyphen = simd_and(temp3, temp20);
691        lex.Equals = simd_and(temp8, temp20);
692        temp24 = simd_and(temp4, temp10);
693        lex.SQuote = simd_and(temp3, temp24);
694        temp25 = simd_andc(temp5, temp21);
695        lex.DQuote = simd_and(temp3, temp25);
696        lex.Slash = simd_and(temp3, temp23);
697        temp26 = simd_andc(temp10, temp21);
698        lex.Hash = simd_and(temp3, temp26);
699        temp27 = simd_and(temp16, temp7);
700        temp28 = simd_andc(temp9, temp13);
701        lex.x = simd_and(temp27, temp28);
702        temp29 = simd_and(temp9, temp5);
703        lex.Colon = simd_and(temp8, temp29);
704        temp30 = simd_and(temp18, temp23);
705        temp31 = simd_or(temp30, lex.Colon);
706        temp32 = simd_andc(temp16, basis_bits.bit_2);
707        temp33 = simd_or(basis_bits.bit_5, temp10);
708        temp34 = simd_and(basis_bits.bit_4, temp33);
709        temp35 = simd_not(temp34);
710        temp36 = simd_or(temp21, temp13);
711        temp37 = simd_or(simd_and(basis_bits.bit_3, temp35), simd_andc(temp36, basis_bits.bit_3));
712        temp38 = simd_and(temp32, temp37);
713        temp39 = simd_or(temp31, temp38);
714        temp40 = simd_and(temp16, basis_bits.bit_2);
715        temp41 = simd_and(temp40, temp37);
716        lex.ASCII_name_start = simd_or(temp39, temp41);
717        temp42 = simd_or(temp30, lex.Hyphen);
718        temp43 = simd_and(temp3, temp15);
719        temp44 = simd_or(temp42, temp43);
720        temp45 = simd_andc(temp8, temp34);
721        temp46 = simd_or(temp44, temp45);
722        temp47 = simd_or(temp46, temp38);
723        lex.ASCII_name_char = simd_or(temp47, temp41);
724        lex.NameScan = simd_or(lex.ASCII_name_char, basis_bits.bit_0);
725        temp48 = simd_or(temp1, basis_bits.bit_2);
726        x00_x1F = simd_not(temp48);
727        temp49 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
728        temp50 = simd_or(temp1, temp49);
729        lex.CR = simd_andc(temp20, temp50);
730        lex.LF = simd_andc(temp29, temp50);
731        temp51 = simd_and(temp9, temp19);
732        lex.HT = simd_andc(temp51, temp50);
733        lex.SP = simd_andc(temp3, temp36);
734        temp52 = simd_or(temp20, temp29);
735        temp53 = simd_or(temp52, temp51);
736        temp54 = simd_andc(temp53, temp50);
737        lex.WS = simd_or(temp54, lex.SP);
738        temp55 = simd_or(basis_bits.bit_5, basis_bits.bit_6);
739        temp56 = simd_and(basis_bits.bit_4, temp55);
740        lex.Digit = simd_andc(temp8, temp56);
741        temp57 = simd_andc(temp16, temp49);
742        temp58 = simd_andc(temp57, basis_bits.bit_4);
743        temp59 = simd_not(temp10);
744        temp60 = simd_or(simd_and(basis_bits.bit_5, temp59), simd_andc(temp13, basis_bits.bit_5));
745        temp61 = simd_and(temp58, temp60);
746        temp62 = simd_or(lex.Digit, temp61);
747        temp63 = simd_and(temp16, temp2);
748        temp64 = simd_andc(temp63, basis_bits.bit_4);
749        temp65 = simd_and(temp64, temp60);
750        lex.Hex = simd_or(temp62, temp65);
751        lex_error = simd_andc(x00_x1F, lex.WS);
752        if (bitblock::any(simd_and(lex_error, EOF_mask))) {
753          error_tracker.NoteError("Error: illegal character", lex_error);
754        }
755        u8.unibyte = simd_not(basis_bits.bit_0);
756        u8.suffix = simd<1>::constant<0>();
757        u8_error = simd<1>::constant<0>();
758        u8_FFFE_FFFF = simd<1>::constant<0>();
759        u8anyscope = simd<1>::constant<0>();
760        if ((bitblock::any(basis_bits.bit_0) || carryQ.CarryTest(0, 12))) {
761          u8.prefix = simd_and(basis_bits.bit_0, basis_bits.bit_1);
762          u8.prefix2 = simd_andc(u8.prefix, basis_bits.bit_2);
763          u8.prefix3 = simd_and(u8.prefix, temp2);
764          u8.prefix4 = simd_and(u8.prefix, temp7);
765          u8.suffix = simd_andc(basis_bits.bit_0, basis_bits.bit_1);
766          temp66 = simd_andc(u8.prefix, temp49);
767          temp67 = simd_or(temp21, basis_bits.bit_6);
768          temp68 = simd_andc(temp66, temp67);
769          temp69 = simd_and(basis_bits.bit_5, temp13);
770          temp70 = simd_or(basis_bits.bit_4, temp69);
771          temp71 = simd_and(u8.prefix4, temp70);
772          u8.badprefix = simd_or(temp68, temp71);
773          u8_error = u8.badprefix;
774          u8.scope22 = carryQ.BitBlock_advance_ci_co(u8.prefix2, carryQ.get_carry_in(0), 0);
775          u8anyscope = u8.scope22;
776          if ((bitblock::any(simd_or(u8.prefix3, u8.prefix4)) || carryQ.CarryTest(1, 11))) {
777            xE0 = simd_andc(u8.prefix3, temp36);
778            xED = simd_and(u8.prefix3, temp20);
779            xF0 = simd_andc(u8.prefix4, temp36);
780            temp72 = simd_andc(temp4, temp13);
781            xF4 = simd_and(u8.prefix4, temp72);
782            u8.xA0_xBF = simd_and(u8.suffix, basis_bits.bit_2);
783            u8.x80_x9F = simd_andc(u8.suffix, basis_bits.bit_2);
784            u8.x90_xBF = simd_and(u8.suffix, temp49);
785            u8.x80_x8F = simd_andc(u8.suffix, temp49);
786            xEF = simd_and(u8.prefix3, temp23);
787            temp73 = simd_and(u8.suffix, temp7);
788            u8.xBF = simd_and(temp73, temp23);
789            u8.xBE = simd_and(temp73, temp15);
790            u8.xE0_scope = carryQ.BitBlock_advance_ci_co(xE0, carryQ.get_carry_in(1), 1);
791            u8.xED_scope = carryQ.BitBlock_advance_ci_co(xED, carryQ.get_carry_in(2), 2);
792            u8.xF0_scope = carryQ.BitBlock_advance_ci_co(xF0, carryQ.get_carry_in(3), 3);
793            u8.xF4_scope = carryQ.BitBlock_advance_ci_co(xF4, carryQ.get_carry_in(4), 4);
794            u8.xEF_scope = carryQ.BitBlock_advance_ci_co(xEF, carryQ.get_carry_in(5), 5);
795            u8.scope32 = carryQ.BitBlock_advance_ci_co(u8.prefix3, carryQ.get_carry_in(6), 6);
796            u8.scope33 = carryQ.BitBlock_advance_ci_co(u8.scope32, carryQ.get_carry_in(7), 7);
797            u8.scope42 = carryQ.BitBlock_advance_ci_co(u8.prefix4, carryQ.get_carry_in(8), 8);
798            u8.scope43 = carryQ.BitBlock_advance_ci_co(u8.scope42, carryQ.get_carry_in(9), 9);
799            u8.scope44 = carryQ.BitBlock_advance_ci_co(u8.scope43, carryQ.get_carry_in(10), 10);
800            u8lastscope = simd_or(simd_or(u8.scope22, u8.scope33), u8.scope44);
801            u8anyscope = simd_or(simd_or(simd_or(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
802            u8error1 = simd_and(u8.xE0_scope, u8.x80_x9F);
803            u8error2 = simd_and(u8.xED_scope, u8.xA0_xBF);
804            u8error3 = simd_and(u8.xF0_scope, u8.x80_x8F);
805            u8error4 = simd_and(u8.xF4_scope, u8.x90_xBF);
806            u8_error = simd_or(u8_error, simd_or(simd_or(simd_or(u8error1, u8error2), u8error3), u8error4));
807            EF_BF_pending = carryQ.BitBlock_advance_ci_co(simd_and(u8.xEF_scope, u8.xBF), carryQ.get_carry_in(11), 11);
808            u8_FFFE_FFFF = simd_and(EF_BF_pending, simd_or(u8.xBE, u8.xBF));
809          }
810          else {
811            carryQ.CarryDequeueEnqueue(1, 11);
812          }
813          u8mismatch = simd_xor(u8anyscope, u8.suffix);
814          u8_error = simd_or(u8_error, simd_or(u8mismatch, u8_FFFE_FFFF));
815          if (bitblock::any(u8_error)) {
816            error_tracker.NoteError("UTF-8 error found", u8_error);
817          }
818        }
819        else {
820          carryQ.CarryDequeueEnqueue(0, 12);
821        }
822        carryQ.CarryQ_Adjust(12);
823  }
824  void do_final_block(Basis_bits & basis_bits, Lex & lex, U8 & u8, BitBlock EOF_mask) {
825                BitBlock temp1, temp2, temp3, temp4, temp5, temp6, temp7, temp8, temp9, temp10;
826                BitBlock temp11, temp12, temp13, temp14, temp15, temp16, temp17, temp18;
827                BitBlock temp19, temp20, temp21, temp22, temp23, temp24, temp25, temp26;
828                BitBlock temp27, temp28, temp29, temp30, temp31, temp32, temp33, temp34;
829                BitBlock temp35, temp36, temp37, temp38, temp39, temp40, temp41, temp42;
830                BitBlock temp43, temp44, temp45, temp46, temp47, temp48, x00_x1F, temp49;
831                BitBlock temp50, temp51, temp52, temp53, temp54, temp55, temp56, temp57;
832                BitBlock temp58, temp59, temp60, temp61, temp62, temp63, temp64, temp65;
833                BitBlock lex_error, u8_error, u8_FFFE_FFFF, u8anyscope, temp66, temp67, temp68;
834                BitBlock temp69, temp70, temp71, xE0, xED, xF0, temp72, xF4, xEF, temp73;
835                BitBlock u8lastscope, u8error1, u8error2, u8error3, u8error4, EF_BF_pending;
836                BitBlock u8mismatch;
837
838
839        temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
840        temp2 = simd_andc(basis_bits.bit_2, basis_bits.bit_3);
841        temp3 = simd_andc(temp2, temp1);
842        temp4 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
843        temp5 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
844        temp6 = simd_and(temp4, temp5);
845        lex.RefStart = simd_and(temp3, temp6);
846        temp7 = simd_and(basis_bits.bit_2, basis_bits.bit_3);
847        temp8 = simd_andc(temp7, temp1);
848        temp9 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
849        temp10 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
850        temp11 = simd_and(temp9, temp10);
851        lex.Semicolon = simd_and(temp8, temp11);
852        temp12 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
853        temp13 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
854        temp14 = simd_andc(temp12, temp13);
855        lex.LAngle = simd_and(temp8, temp14);
856        temp15 = simd_and(temp12, temp5);
857        lex.RAngle = simd_and(temp8, temp15);
858        temp16 = simd_andc(basis_bits.bit_1, basis_bits.bit_0);
859        temp17 = simd_andc(basis_bits.bit_3, basis_bits.bit_2);
860        temp18 = simd_and(temp16, temp17);
861        lex.LBracket = simd_and(temp18, temp11);
862        temp19 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
863        temp20 = simd_and(temp12, temp19);
864        lex.RBracket = simd_and(temp18, temp20);
865        temp21 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
866        temp22 = simd_andc(temp19, temp21);
867        lex.Exclam = simd_and(temp3, temp22);
868        temp23 = simd_and(temp12, temp10);
869        lex.QMark = simd_and(temp8, temp23);
870        lex.Hyphen = simd_and(temp3, temp20);
871        lex.Equals = simd_and(temp8, temp20);
872        temp24 = simd_and(temp4, temp10);
873        lex.SQuote = simd_and(temp3, temp24);
874        temp25 = simd_andc(temp5, temp21);
875        lex.DQuote = simd_and(temp3, temp25);
876        lex.Slash = simd_and(temp3, temp23);
877        temp26 = simd_andc(temp10, temp21);
878        lex.Hash = simd_and(temp3, temp26);
879        temp27 = simd_and(temp16, temp7);
880        temp28 = simd_andc(temp9, temp13);
881        lex.x = simd_and(temp27, temp28);
882        temp29 = simd_and(temp9, temp5);
883        lex.Colon = simd_and(temp8, temp29);
884        temp30 = simd_and(temp18, temp23);
885        temp31 = simd_or(temp30, lex.Colon);
886        temp32 = simd_andc(temp16, basis_bits.bit_2);
887        temp33 = simd_or(basis_bits.bit_5, temp10);
888        temp34 = simd_and(basis_bits.bit_4, temp33);
889        temp35 = simd_not(temp34);
890        temp36 = simd_or(temp21, temp13);
891        temp37 = simd_or(simd_and(basis_bits.bit_3, temp35), simd_andc(temp36, basis_bits.bit_3));
892        temp38 = simd_and(temp32, temp37);
893        temp39 = simd_or(temp31, temp38);
894        temp40 = simd_and(temp16, basis_bits.bit_2);
895        temp41 = simd_and(temp40, temp37);
896        lex.ASCII_name_start = simd_or(temp39, temp41);
897        temp42 = simd_or(temp30, lex.Hyphen);
898        temp43 = simd_and(temp3, temp15);
899        temp44 = simd_or(temp42, temp43);
900        temp45 = simd_andc(temp8, temp34);
901        temp46 = simd_or(temp44, temp45);
902        temp47 = simd_or(temp46, temp38);
903        lex.ASCII_name_char = simd_or(temp47, temp41);
904        lex.NameScan = simd_or(lex.ASCII_name_char, basis_bits.bit_0);
905        temp48 = simd_or(temp1, basis_bits.bit_2);
906        x00_x1F = simd_not(temp48);
907        temp49 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
908        temp50 = simd_or(temp1, temp49);
909        lex.CR = simd_andc(temp20, temp50);
910        lex.LF = simd_andc(temp29, temp50);
911        temp51 = simd_and(temp9, temp19);
912        lex.HT = simd_andc(temp51, temp50);
913        lex.SP = simd_andc(temp3, temp36);
914        temp52 = simd_or(temp20, temp29);
915        temp53 = simd_or(temp52, temp51);
916        temp54 = simd_andc(temp53, temp50);
917        lex.WS = simd_or(temp54, lex.SP);
918        temp55 = simd_or(basis_bits.bit_5, basis_bits.bit_6);
919        temp56 = simd_and(basis_bits.bit_4, temp55);
920        lex.Digit = simd_andc(temp8, temp56);
921        temp57 = simd_andc(temp16, temp49);
922        temp58 = simd_andc(temp57, basis_bits.bit_4);
923        temp59 = simd_not(temp10);
924        temp60 = simd_or(simd_and(basis_bits.bit_5, temp59), simd_andc(temp13, basis_bits.bit_5));
925        temp61 = simd_and(temp58, temp60);
926        temp62 = simd_or(lex.Digit, temp61);
927        temp63 = simd_and(temp16, temp2);
928        temp64 = simd_andc(temp63, basis_bits.bit_4);
929        temp65 = simd_and(temp64, temp60);
930        lex.Hex = simd_or(temp62, temp65);
931        lex_error = simd_andc(x00_x1F, lex.WS);
932        if (bitblock::any(simd_and(lex_error, EOF_mask))) {
933          error_tracker.NoteError("Error: illegal character", lex_error);
934        }
935        u8.unibyte = simd_not(basis_bits.bit_0);
936        u8.suffix = simd<1>::constant<0>();
937        u8_error = simd<1>::constant<0>();
938        u8_FFFE_FFFF = simd<1>::constant<0>();
939        u8anyscope = simd<1>::constant<0>();
940        if ((bitblock::any(basis_bits.bit_0) || carryQ.CarryTest(0, 12))) {
941          u8.prefix = simd_and(basis_bits.bit_0, basis_bits.bit_1);
942          u8.prefix2 = simd_andc(u8.prefix, basis_bits.bit_2);
943          u8.prefix3 = simd_and(u8.prefix, temp2);
944          u8.prefix4 = simd_and(u8.prefix, temp7);
945          u8.suffix = simd_andc(basis_bits.bit_0, basis_bits.bit_1);
946          temp66 = simd_andc(u8.prefix, temp49);
947          temp67 = simd_or(temp21, basis_bits.bit_6);
948          temp68 = simd_andc(temp66, temp67);
949          temp69 = simd_and(basis_bits.bit_5, temp13);
950          temp70 = simd_or(basis_bits.bit_4, temp69);
951          temp71 = simd_and(u8.prefix4, temp70);
952          u8.badprefix = simd_or(temp68, temp71);
953          u8_error = u8.badprefix;
954          u8.scope22 = carryQ.BitBlock_advance_ci_co(u8.prefix2, carryQ.get_carry_in(0), 0);
955          u8anyscope = u8.scope22;
956          if ((bitblock::any(simd_or(u8.prefix3, u8.prefix4)) || carryQ.CarryTest(1, 11))) {
957            xE0 = simd_andc(u8.prefix3, temp36);
958            xED = simd_and(u8.prefix3, temp20);
959            xF0 = simd_andc(u8.prefix4, temp36);
960            temp72 = simd_andc(temp4, temp13);
961            xF4 = simd_and(u8.prefix4, temp72);
962            u8.xA0_xBF = simd_and(u8.suffix, basis_bits.bit_2);
963            u8.x80_x9F = simd_andc(u8.suffix, basis_bits.bit_2);
964            u8.x90_xBF = simd_and(u8.suffix, temp49);
965            u8.x80_x8F = simd_andc(u8.suffix, temp49);
966            xEF = simd_and(u8.prefix3, temp23);
967            temp73 = simd_and(u8.suffix, temp7);
968            u8.xBF = simd_and(temp73, temp23);
969            u8.xBE = simd_and(temp73, temp15);
970            u8.xE0_scope = carryQ.BitBlock_advance_ci_co(xE0, carryQ.get_carry_in(1), 1);
971            u8.xED_scope = carryQ.BitBlock_advance_ci_co(xED, carryQ.get_carry_in(2), 2);
972            u8.xF0_scope = carryQ.BitBlock_advance_ci_co(xF0, carryQ.get_carry_in(3), 3);
973            u8.xF4_scope = carryQ.BitBlock_advance_ci_co(xF4, carryQ.get_carry_in(4), 4);
974            u8.xEF_scope = carryQ.BitBlock_advance_ci_co(xEF, carryQ.get_carry_in(5), 5);
975            u8.scope32 = carryQ.BitBlock_advance_ci_co(u8.prefix3, carryQ.get_carry_in(6), 6);
976            u8.scope33 = carryQ.BitBlock_advance_ci_co(u8.scope32, carryQ.get_carry_in(7), 7);
977            u8.scope42 = carryQ.BitBlock_advance_ci_co(u8.prefix4, carryQ.get_carry_in(8), 8);
978            u8.scope43 = carryQ.BitBlock_advance_ci_co(u8.scope42, carryQ.get_carry_in(9), 9);
979            u8.scope44 = carryQ.BitBlock_advance_ci_co(u8.scope43, carryQ.get_carry_in(10), 10);
980            u8lastscope = simd_or(simd_or(u8.scope22, u8.scope33), u8.scope44);
981            u8anyscope = simd_or(simd_or(simd_or(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
982            u8error1 = simd_and(u8.xE0_scope, u8.x80_x9F);
983            u8error2 = simd_and(u8.xED_scope, u8.xA0_xBF);
984            u8error3 = simd_and(u8.xF0_scope, u8.x80_x8F);
985            u8error4 = simd_and(u8.xF4_scope, u8.x90_xBF);
986            u8_error = simd_or(u8_error, simd_or(simd_or(simd_or(u8error1, u8error2), u8error3), u8error4));
987            EF_BF_pending = carryQ.BitBlock_advance_ci_co(simd_and(u8.xEF_scope, u8.xBF), carryQ.get_carry_in(11), 11);
988            u8_FFFE_FFFF = simd_and(EF_BF_pending, simd_or(u8.xBE, u8.xBF));
989          }
990          else {
991            carryQ.CarryDequeueEnqueue(1, 11);
992          }
993          u8mismatch = simd_xor(u8anyscope, u8.suffix);
994          u8_error = simd_or(u8_error, simd_or(u8mismatch, u8_FFFE_FFFF));
995          if (bitblock::any(u8_error)) {
996            error_tracker.NoteError("UTF-8 error found", u8_error);
997          }
998        }
999        else {
1000          carryQ.CarryDequeueEnqueue(0, 12);
1001        }
1002  }
1003  void do_segment(Basis_bits basis_bits[], Lex lex[], U8 u8[], int segment_blocks) {
1004  int i;
1005  for (i = 0; i < segment_blocks; i++)
1006    do_block(basis_bits[i], lex[i], u8[i]);
1007  }
1008  CarryArray<12> carryQ;
1009  };
1010
1011  struct Parse_CtCDPI {
1012  Parse_CtCDPI() { 
1013 }
1014  IDISA_INLINE void do_block(CtCDPI_Callouts & ctCDPI_Callouts, Lex & lex, Scope1 & scope1, Check_streams & check_streams) {
1015                BitBlock ctCDPI_error, CtCDPI_starts, Ct_errors, PI_start, CtCD_start;
1016                BitBlock CtCDPI_start, DoubleHyphen, PI_end, CtCDPI_Cursor, PI_Cursor;
1017                BitBlock CD_Ct_Cursor, CD_Cursor, Ct_Cursor, PI_name_end;
1018
1019
1020        ctCDPI_Callouts.CD_end = simd<1>::constant<0>();
1021        ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
1022        ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
1023        ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
1024        ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
1025        ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
1026        ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
1027        ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
1028        ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
1029        ctCDPI_Callouts.CtCDPI_mask = simd<1>::constant<0>();
1030        ctCDPI_error = simd<1>::constant<0>();
1031        CtCDPI_starts = simd<1>::constant<0>();
1032        Ct_errors = simd<1>::constant<0>();
1033        if ((bitblock::any(lex.RBracket) || carryQ.CarryTest(0, 2))) {
1034          scope1.RBracket = carryQ.BitBlock_advance_ci_co(lex.RBracket, carryQ.get_carry_in(0), 0);
1035          ctCDPI_Callouts.CD_end = simd_and(carryQ.BitBlock_advance_ci_co(simd_and(scope1.RBracket, lex.RBracket), carryQ.get_carry_in(1), 1), lex.RAngle);
1036        }
1037        else {
1038          carryQ.CarryDequeueEnqueue(0, 2);
1039        }
1040        PI_start = simd_and(scope1.LAngle, lex.QMark);
1041        CtCD_start = simd_and(scope1.LAngle, lex.Exclam);
1042        CtCDPI_start = simd_or(PI_start, CtCD_start);
1043        DoubleHyphen = simd_and(scope1.Hyphen, lex.Hyphen);
1044        PI_end = simd_and(scope1.QMark, lex.RAngle);
1045        CtCDPI_Cursor = carryQ.BitBlock_scantofirst(CtCDPI_start, carryQ.get_carry_in(2), 2);
1046        if ((bitblock::any(CtCDPI_Cursor) || carryQ.CarryTest(3, 14))) {
1047          CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
1048          PI_Cursor = simd_and(CtCDPI_Cursor, PI_start);
1049          CD_Ct_Cursor = carryQ.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), carryQ.get_carry_in(3), 3);
1050          CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
1051          Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
1052          ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
1053          ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
1054          ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
1055          Ct_Cursor = carryQ.BitBlock_advance_ci_co(Ct_Cursor, carryQ.get_carry_in(4), 4);
1056          Ct_errors = simd_or(Ct_errors, simd_andc(Ct_Cursor, lex.Hyphen));
1057          Ct_Cursor = carryQ.BitBlock_advance_ci_co(carryQ.BitBlock_advance_ci_co(Ct_Cursor, carryQ.get_carry_in(5), 5), carryQ.get_carry_in(6), 6);
1058          PI_Cursor = carryQ.BitBlock_advance_ci_co(PI_Cursor, carryQ.get_carry_in(7), 7);
1059          ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
1060          PI_name_end = carryQ.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, carryQ.get_carry_in(8), 8);
1061          ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
1062          PI_Cursor = carryQ.BitBlock_scanthru_ci_co(PI_name_end, simd_not(PI_end), carryQ.get_carry_in(9), 9);
1063          CD_Cursor = carryQ.BitBlock_scanthru_ci_co(CD_Cursor, simd_not(ctCDPI_Callouts.CD_end), carryQ.get_carry_in(10), 10);
1064          Ct_Cursor = carryQ.BitBlock_advance_ci_co(carryQ.BitBlock_scanthru_ci_co(Ct_Cursor, simd_not(DoubleHyphen), carryQ.get_carry_in(11), 11), carryQ.get_carry_in(12), 12);
1065          ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
1066          ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
1067          ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
1068          CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
1069          CtCDPI_Cursor = carryQ.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_not(CtCDPI_start), carryQ.get_carry_in(13), 13);
1070          ctCDPI_Callouts.CtCDPI_mask = carryQ.BitBlock_sub_ci_co(carryQ.BitBlock_advance_ci_co(simd_or(simd_or(ctCDPI_Callouts.CD_ends, ctCDPI_Callouts.Ct_ends), ctCDPI_Callouts.PI_ends), carryQ.get_carry_in(14), 14), CtCDPI_starts, carryQ.get_carry_in(15), 15);
1071          ctCDPI_error = simd_or(Ct_errors, simd_andc(ctCDPI_Callouts.Ct_ends, lex.RAngle));
1072          ctCDPI_error = simd_or(ctCDPI_error, simd_andc(carryQ.BitBlock_advance_ci_co(simd_andc(ctCDPI_Callouts.PI_name_ends, lex.WS), carryQ.get_carry_in(16), 16), PI_end));
1073          ctCDPI_error = simd_or(ctCDPI_error, simd_and(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends));
1074          ctCDPI_error = simd_or(ctCDPI_error, simd_andc(ctCDPI_Callouts.CtCDPI_mask, EOF_mask));
1075          while (bitblock::any(CtCDPI_Cursor)) {
1076            LocalCarryDeclare(subcarryQ, 14);
1077            CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
1078            PI_Cursor = simd_and(CtCDPI_Cursor, PI_start);
1079            CD_Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), simd<1>::constant<0>(), 0);
1080            CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
1081            Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
1082            ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
1083            ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
1084            ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
1085            Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 1);
1086            Ct_errors = simd_or(Ct_errors, simd_andc(Ct_Cursor, lex.Hyphen));
1087            Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(subcarryQ.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 2), simd<1>::constant<0>(), 3);
1088            PI_Cursor = subcarryQ.BitBlock_advance_ci_co(PI_Cursor, simd<1>::constant<0>(), 4);
1089            ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
1090            PI_name_end = subcarryQ.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, simd<1>::constant<0>(), 5);
1091            ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
1092            PI_Cursor = subcarryQ.BitBlock_scanthru_ci_co(PI_name_end, simd_not(PI_end), simd<1>::constant<0>(), 6);
1093            CD_Cursor = subcarryQ.BitBlock_scanthru_ci_co(CD_Cursor, simd_not(ctCDPI_Callouts.CD_end), simd<1>::constant<0>(), 7);
1094            Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(subcarryQ.BitBlock_scanthru_ci_co(Ct_Cursor, simd_not(DoubleHyphen), simd<1>::constant<0>(), 8), simd<1>::constant<0>(), 9);
1095            ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
1096            ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
1097            ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
1098            CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
1099            CtCDPI_Cursor = subcarryQ.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_not(CtCDPI_start), simd<1>::constant<0>(), 10);
1100            ctCDPI_Callouts.CtCDPI_mask = subcarryQ.BitBlock_sub_ci_co(subcarryQ.BitBlock_advance_ci_co(simd_or(simd_or(ctCDPI_Callouts.CD_ends, ctCDPI_Callouts.Ct_ends), ctCDPI_Callouts.PI_ends), simd<1>::constant<0>(), 11), CtCDPI_starts, simd<1>::constant<0>(), 12);
1101            ctCDPI_error = simd_or(Ct_errors, simd_andc(ctCDPI_Callouts.Ct_ends, lex.RAngle));
1102            ctCDPI_error = simd_or(ctCDPI_error, simd_andc(subcarryQ.BitBlock_advance_ci_co(simd_andc(ctCDPI_Callouts.PI_name_ends, lex.WS), simd<1>::constant<0>(), 13), PI_end));
1103            ctCDPI_error = simd_or(ctCDPI_error, simd_and(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends));
1104            ctCDPI_error = simd_or(ctCDPI_error, simd_andc(ctCDPI_Callouts.CtCDPI_mask, EOF_mask));
1105            carryQ.CarryCombine((ICarryQueue *) &subcarryQ, 3, 14);
1106          }
1107        }
1108        else {
1109          carryQ.CarryDequeueEnqueue(3, 14);
1110        }
1111        if (bitblock::any(ctCDPI_error)) {
1112          error_tracker.NoteError("Error in comment, CDATA or processing instruction syntax", ctCDPI_error);
1113        }
1114        check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS, lex.LAngle), carryQ.BitBlock_sub_ci_co(carryQ.BitBlock_advance_ci_co(simd_or(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carryQ.get_carry_in(17), 17), simd_or(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), carryQ.get_carry_in(18), 18)), CtCDPI_starts), EOF_mask);
1115        carryQ.CarryQ_Adjust(19);
1116  }
1117  void do_final_block(CtCDPI_Callouts & ctCDPI_Callouts, Lex & lex, Scope1 & scope1, Check_streams & check_streams, BitBlock EOF_mask) {
1118                BitBlock ctCDPI_error, CtCDPI_starts, Ct_errors, PI_start, CtCD_start;
1119                BitBlock CtCDPI_start, DoubleHyphen, PI_end, CtCDPI_Cursor, PI_Cursor;
1120                BitBlock CD_Ct_Cursor, CD_Cursor, Ct_Cursor, PI_name_end;
1121
1122
1123        ctCDPI_Callouts.CD_end = simd<1>::constant<0>();
1124        ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
1125        ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
1126        ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
1127        ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
1128        ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
1129        ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
1130        ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
1131        ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
1132        ctCDPI_Callouts.CtCDPI_mask = simd<1>::constant<0>();
1133        ctCDPI_error = simd<1>::constant<0>();
1134        CtCDPI_starts = simd<1>::constant<0>();
1135        Ct_errors = simd<1>::constant<0>();
1136        if ((bitblock::any(lex.RBracket) || carryQ.CarryTest(0, 2))) {
1137          scope1.RBracket = carryQ.BitBlock_advance_ci_co(lex.RBracket, carryQ.get_carry_in(0), 0);
1138          ctCDPI_Callouts.CD_end = simd_and(carryQ.BitBlock_advance_ci_co(simd_and(scope1.RBracket, lex.RBracket), carryQ.get_carry_in(1), 1), lex.RAngle);
1139        }
1140        else {
1141          carryQ.CarryDequeueEnqueue(0, 2);
1142        }
1143        PI_start = simd_and(scope1.LAngle, lex.QMark);
1144        CtCD_start = simd_and(scope1.LAngle, lex.Exclam);
1145        CtCDPI_start = simd_or(PI_start, CtCD_start);
1146        DoubleHyphen = simd_and(scope1.Hyphen, lex.Hyphen);
1147        PI_end = simd_and(scope1.QMark, lex.RAngle);
1148        CtCDPI_Cursor = carryQ.BitBlock_scantofirst(CtCDPI_start, carryQ.get_carry_in(2), 2);
1149        if ((bitblock::any(simd_and(CtCDPI_Cursor, EOF_mask)) || carryQ.CarryTest(3, 14))) {
1150          CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
1151          PI_Cursor = simd_and(CtCDPI_Cursor, PI_start);
1152          CD_Ct_Cursor = carryQ.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), carryQ.get_carry_in(3), 3);
1153          CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
1154          Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
1155          ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
1156          ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
1157          ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
1158          Ct_Cursor = carryQ.BitBlock_advance_ci_co(Ct_Cursor, carryQ.get_carry_in(4), 4);
1159          Ct_errors = simd_or(Ct_errors, simd_andc(Ct_Cursor, lex.Hyphen));
1160          Ct_Cursor = carryQ.BitBlock_advance_ci_co(carryQ.BitBlock_advance_ci_co(Ct_Cursor, carryQ.get_carry_in(5), 5), carryQ.get_carry_in(6), 6);
1161          PI_Cursor = carryQ.BitBlock_advance_ci_co(PI_Cursor, carryQ.get_carry_in(7), 7);
1162          ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
1163          PI_name_end = carryQ.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, carryQ.get_carry_in(8), 8);
1164          ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
1165          PI_Cursor = carryQ.BitBlock_scanthru_ci_co(PI_name_end, simd_andc(EOF_mask, PI_end), carryQ.get_carry_in(9), 9);
1166          CD_Cursor = carryQ.BitBlock_scanthru_ci_co(CD_Cursor, simd_andc(EOF_mask, ctCDPI_Callouts.CD_end), carryQ.get_carry_in(10), 10);
1167          Ct_Cursor = carryQ.BitBlock_advance_ci_co(carryQ.BitBlock_scanthru_ci_co(Ct_Cursor, simd_andc(EOF_mask, DoubleHyphen), carryQ.get_carry_in(11), 11), carryQ.get_carry_in(12), 12);
1168          ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
1169          ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
1170          ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
1171          CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
1172          CtCDPI_Cursor = carryQ.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_start), carryQ.get_carry_in(13), 13);
1173          ctCDPI_Callouts.CtCDPI_mask = carryQ.BitBlock_sub_ci_co(carryQ.BitBlock_advance_ci_co(simd_or(simd_or(ctCDPI_Callouts.CD_ends, ctCDPI_Callouts.Ct_ends), ctCDPI_Callouts.PI_ends), carryQ.get_carry_in(14), 14), CtCDPI_starts, carryQ.get_carry_in(15), 15);
1174          ctCDPI_error = simd_or(Ct_errors, simd_andc(ctCDPI_Callouts.Ct_ends, lex.RAngle));
1175          ctCDPI_error = simd_or(ctCDPI_error, simd_andc(carryQ.BitBlock_advance_ci_co(simd_andc(ctCDPI_Callouts.PI_name_ends, lex.WS), carryQ.get_carry_in(16), 16), PI_end));
1176          ctCDPI_error = simd_or(ctCDPI_error, simd_and(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends));
1177          ctCDPI_error = simd_or(ctCDPI_error, simd_andc(ctCDPI_Callouts.CtCDPI_mask, EOF_mask));
1178          while (bitblock::any(simd_and(CtCDPI_Cursor, EOF_mask))) {
1179            LocalCarryDeclare(subcarryQ, 14);
1180            CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
1181            PI_Cursor = simd_and(CtCDPI_Cursor, PI_start);
1182            CD_Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), simd<1>::constant<0>(), 0);
1183            CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
1184            Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
1185            ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
1186            ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
1187            ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
1188            Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 1);
1189            Ct_errors = simd_or(Ct_errors, simd_andc(Ct_Cursor, lex.Hyphen));
1190            Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(subcarryQ.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 2), simd<1>::constant<0>(), 3);
1191            PI_Cursor = subcarryQ.BitBlock_advance_ci_co(PI_Cursor, simd<1>::constant<0>(), 4);
1192            ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
1193            PI_name_end = subcarryQ.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, simd<1>::constant<0>(), 5);
1194            ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
1195            PI_Cursor = subcarryQ.BitBlock_scanthru_ci_co(PI_name_end, simd_andc(EOF_mask, PI_end), simd<1>::constant<0>(), 6);
1196            CD_Cursor = subcarryQ.BitBlock_scanthru_ci_co(CD_Cursor, simd_andc(EOF_mask, ctCDPI_Callouts.CD_end), simd<1>::constant<0>(), 7);
1197            Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(subcarryQ.BitBlock_scanthru_ci_co(Ct_Cursor, simd_andc(EOF_mask, DoubleHyphen), simd<1>::constant<0>(), 8), simd<1>::constant<0>(), 9);
1198            ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
1199            ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
1200            ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
1201            CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
1202            CtCDPI_Cursor = subcarryQ.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_start), simd<1>::constant<0>(), 10);
1203            ctCDPI_Callouts.CtCDPI_mask = subcarryQ.BitBlock_sub_ci_co(subcarryQ.BitBlock_advance_ci_co(simd_or(simd_or(ctCDPI_Callouts.CD_ends, ctCDPI_Callouts.Ct_ends), ctCDPI_Callouts.PI_ends), simd<1>::constant<0>(), 11), CtCDPI_starts, simd<1>::constant<0>(), 12);
1204            ctCDPI_error = simd_or(Ct_errors, simd_andc(ctCDPI_Callouts.Ct_ends, lex.RAngle));
1205            ctCDPI_error = simd_or(ctCDPI_error, simd_andc(subcarryQ.BitBlock_advance_ci_co(simd_andc(ctCDPI_Callouts.PI_name_ends, lex.WS), simd<1>::constant<0>(), 13), PI_end));
1206            ctCDPI_error = simd_or(ctCDPI_error, simd_and(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends));
1207            ctCDPI_error = simd_or(ctCDPI_error, simd_andc(ctCDPI_Callouts.CtCDPI_mask, EOF_mask));
1208            carryQ.CarryCombine((ICarryQueue *) &subcarryQ, 3, 14);
1209          }
1210        }
1211        else {
1212          carryQ.CarryDequeueEnqueue(3, 14);
1213        }
1214        if (bitblock::any(ctCDPI_error)) {
1215          error_tracker.NoteError("Error in comment, CDATA or processing instruction syntax", ctCDPI_error);
1216        }
1217        check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS, lex.LAngle), carryQ.BitBlock_sub_ci_co(carryQ.BitBlock_advance_ci_co(simd_or(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carryQ.get_carry_in(17), 17), simd_or(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), carryQ.get_carry_in(18), 18)), CtCDPI_starts), EOF_mask);
1218  }
1219  void do_segment(CtCDPI_Callouts ctCDPI_Callouts[], Lex lex[], Scope1 scope1[], Check_streams check_streams[], int segment_blocks) {
1220  int i;
1221  for (i = 0; i < segment_blocks; i++)
1222    do_block(ctCDPI_Callouts[i], lex[i], scope1[i], check_streams[i]);
1223  }
1224  CarryArray<19> carryQ;
1225  };
1226
1227  struct Validation_Vec_2 {
1228  Validation_Vec_2() { 
1229 }
1230  IDISA_INLINE void do_block(Citygml & citygml, Basis_bits & basis_bits) {
1231                BitBlock temp1, temp2, temp3, temp4, temp5, temp6, temp7, temp8, temp9, temp10;
1232                BitBlock temp11, temp12, temp13, temp14, temp15, temp16, temp17;
1233                BitBlock apperance_scope, vec_2_error1;
1234
1235
1236        temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
1237        temp2 = simd_and(basis_bits.bit_2, basis_bits.bit_3);
1238        temp3 = simd_andc(temp2, temp1);
1239        temp4 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
1240        temp5 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
1241        temp6 = simd_or(temp4, temp5);
1242        temp7 = simd_andc(temp3, temp6);
1243        temp8 = simd_andc(basis_bits.bit_1, basis_bits.bit_0);
1244        temp9 = simd_and(temp8, temp2);
1245        temp10 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
1246        temp11 = simd_andc(temp10, temp5);
1247        temp12 = simd_and(temp9, temp11);
1248        temp13 = simd_or(temp7, temp12);
1249        temp14 = simd_or(temp13, temp7);
1250        citygml.null = simd_or(temp14, temp7);
1251        temp15 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
1252        temp16 = simd_andc(temp15, temp4);
1253        temp17 = simd_and(temp3, temp16);
1254        citygml.Appearance = simd_or(temp14, temp17);
1255        apperance_scope = carryQ.BitBlock_advance_ci_co(citygml.Appearance, carryQ.get_carry_in(0), 0);
1256        vec_2_error1 = simd_andc(apperance_scope, citygml.null);
1257        if (bitblock::any(vec_2_error1)) {
1258          error_tracker.NoteError("Vec_2_error found", vec_2_error1);
1259        }
1260        carryQ.CarryQ_Adjust(1);
1261  }
1262  void do_final_block(Citygml & citygml, Basis_bits & basis_bits, BitBlock EOF_mask) {
1263                BitBlock temp1, temp2, temp3, temp4, temp5, temp6, temp7, temp8, temp9, temp10;
1264                BitBlock temp11, temp12, temp13, temp14, temp15, temp16, temp17;
1265                BitBlock apperance_scope, vec_2_error1;
1266
1267
1268        temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
1269        temp2 = simd_and(basis_bits.bit_2, basis_bits.bit_3);
1270        temp3 = simd_andc(temp2, temp1);
1271        temp4 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
1272        temp5 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
1273        temp6 = simd_or(temp4, temp5);
1274        temp7 = simd_andc(temp3, temp6);
1275        temp8 = simd_andc(basis_bits.bit_1, basis_bits.bit_0);
1276        temp9 = simd_and(temp8, temp2);
1277        temp10 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
1278        temp11 = simd_andc(temp10, temp5);
1279        temp12 = simd_and(temp9, temp11);
1280        temp13 = simd_or(temp7, temp12);
1281        temp14 = simd_or(temp13, temp7);
1282        citygml.null = simd_or(temp14, temp7);
1283        temp15 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
1284        temp16 = simd_andc(temp15, temp4);
1285        temp17 = simd_and(temp3, temp16);
1286        citygml.Appearance = simd_or(temp14, temp17);
1287        apperance_scope = carryQ.BitBlock_advance_ci_co(citygml.Appearance, carryQ.get_carry_in(0), 0);
1288        vec_2_error1 = simd_andc(apperance_scope, citygml.null);
1289        if (bitblock::any(vec_2_error1)) {
1290          error_tracker.NoteError("Vec_2_error found", vec_2_error1);
1291        }
1292  }
1293  void do_segment(Citygml citygml[], Basis_bits basis_bits[], int segment_blocks) {
1294  int i;
1295  for (i = 0; i < segment_blocks; i++)
1296    do_block(citygml[i], basis_bits[i]);
1297  }
1298  CarryArray<1> carryQ;
1299  };
1300
1301  struct Do_check_streams {
1302 
1303  IDISA_INLINE void do_block(CtCDPI_Callouts & ctCDPI_Callouts, Tag_Callouts & tag_Callouts, Lex & lex, U8 & u8, Scope1 & scope1, Ref_Callouts & ref_Callouts, Xml_names & xml_names, Check_streams & check_streams) {
1304                BitBlock CD_end_error;
1305
1306
1307        CD_end_error = simd_andc(ctCDPI_Callouts.CD_end, simd_or(ctCDPI_Callouts.CtCDPI_mask, tag_Callouts.AttVal_spans));
1308        if (bitblock::any(CD_end_error)) {
1309          error_tracker.NoteError("Error: ]]> in text", CD_end_error);
1310        }
1311        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);
1312        check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends, tag_Callouts.AttName_ends);
1313        check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans, scope1.RefStart);
1314  }
1315  void do_final_block(CtCDPI_Callouts & ctCDPI_Callouts, Tag_Callouts & tag_Callouts, Lex & lex, U8 & u8, Scope1 & scope1, Ref_Callouts & ref_Callouts, Xml_names & xml_names, Check_streams & check_streams, BitBlock EOF_mask) {
1316                BitBlock CD_end_error;
1317
1318
1319        CD_end_error = simd_andc(ctCDPI_Callouts.CD_end, simd_or(ctCDPI_Callouts.CtCDPI_mask, tag_Callouts.AttVal_spans));
1320        if (bitblock::any(CD_end_error)) {
1321          error_tracker.NoteError("Error: ]]> in text", CD_end_error);
1322        }
1323        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);
1324        check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends, tag_Callouts.AttName_ends);
1325        check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans, scope1.RefStart);
1326  }
1327  void do_segment(CtCDPI_Callouts ctCDPI_Callouts[], Tag_Callouts tag_Callouts[], Lex lex[], U8 u8[], Scope1 scope1[], Ref_Callouts ref_Callouts[], Xml_names xml_names[], Check_streams check_streams[], int segment_blocks) {
1328  int i;
1329  for (i = 0; i < segment_blocks; i++)
1330    do_block(ctCDPI_Callouts[i], tag_Callouts[i], lex[i], u8[i], scope1[i], ref_Callouts[i], xml_names[i], check_streams[i]);
1331  }
1332 
1333  };
1334
1335  struct Form_Length_Group_Bitstreams {
1336  Form_Length_Group_Bitstreams() { 
1337 }
1338  IDISA_INLINE void do_block(Tag_Callouts & tag_Callouts) {
1339                BitBlock remaining_starts, remaining_ends, temp;
1340
1341
1342        remaining_starts = tag_Callouts.ElemName_starts;
1343        remaining_ends = tag_Callouts.ElemName_ends;
1344        temp = tag_Callouts.ElemName_starts;
1345        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(0), 0);
1346        tag_Callouts.ElemName_ends_1 = simd_and(temp, remaining_ends);
1347        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_1);
1348        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(1), 1);
1349        tag_Callouts.ElemName_ends_2 = simd_and(temp, remaining_ends);
1350        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_2);
1351        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(2), 2);
1352        tag_Callouts.ElemName_ends_3 = simd_and(temp, remaining_ends);
1353        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_3);
1354        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(3), 3);
1355        tag_Callouts.ElemName_ends_4 = simd_and(temp, remaining_ends);
1356        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_4);
1357        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(4), 4);
1358        tag_Callouts.ElemName_ends_5 = simd_and(temp, remaining_ends);
1359        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_5);
1360        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(5), 5);
1361        tag_Callouts.ElemName_ends_6 = simd_and(temp, remaining_ends);
1362        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_6);
1363        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(6), 6);
1364        tag_Callouts.ElemName_ends_7 = simd_and(temp, remaining_ends);
1365        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_7);
1366        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(7), 7);
1367        tag_Callouts.ElemName_ends_8 = simd_and(temp, remaining_ends);
1368        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_8);
1369        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(8), 8);
1370        tag_Callouts.ElemName_ends_9 = simd_and(temp, remaining_ends);
1371        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_9);
1372        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(9), 9);
1373        tag_Callouts.ElemName_ends_10 = simd_and(temp, remaining_ends);
1374        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_10);
1375        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(10), 10);
1376        tag_Callouts.ElemName_ends_11 = simd_and(temp, remaining_ends);
1377        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_11);
1378        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(11), 11);
1379        tag_Callouts.ElemName_ends_12 = simd_and(temp, remaining_ends);
1380        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_12);
1381        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(12), 12);
1382        tag_Callouts.ElemName_ends_13 = simd_and(temp, remaining_ends);
1383        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_13);
1384        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(13), 13);
1385        tag_Callouts.ElemName_ends_14 = simd_and(temp, remaining_ends);
1386        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_14);
1387        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(14), 14);
1388        tag_Callouts.ElemName_ends_15 = simd_and(temp, remaining_ends);
1389        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_15);
1390        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(15), 15);
1391        tag_Callouts.ElemName_ends_16 = simd_and(temp, remaining_ends);
1392        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_16);
1393        tag_Callouts.ElemName_ends_17_and_longer = remaining_ends;
1394        carryQ.CarryQ_Adjust(16);
1395  }
1396  void do_final_block(Tag_Callouts & tag_Callouts, BitBlock EOF_mask) {
1397                BitBlock remaining_starts, remaining_ends, temp;
1398
1399
1400        remaining_starts = tag_Callouts.ElemName_starts;
1401        remaining_ends = tag_Callouts.ElemName_ends;
1402        temp = tag_Callouts.ElemName_starts;
1403        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(0), 0);
1404        tag_Callouts.ElemName_ends_1 = simd_and(temp, remaining_ends);
1405        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_1);
1406        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(1), 1);
1407        tag_Callouts.ElemName_ends_2 = simd_and(temp, remaining_ends);
1408        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_2);
1409        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(2), 2);
1410        tag_Callouts.ElemName_ends_3 = simd_and(temp, remaining_ends);
1411        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_3);
1412        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(3), 3);
1413        tag_Callouts.ElemName_ends_4 = simd_and(temp, remaining_ends);
1414        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_4);
1415        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(4), 4);
1416        tag_Callouts.ElemName_ends_5 = simd_and(temp, remaining_ends);
1417        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_5);
1418        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(5), 5);
1419        tag_Callouts.ElemName_ends_6 = simd_and(temp, remaining_ends);
1420        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_6);
1421        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(6), 6);
1422        tag_Callouts.ElemName_ends_7 = simd_and(temp, remaining_ends);
1423        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_7);
1424        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(7), 7);
1425        tag_Callouts.ElemName_ends_8 = simd_and(temp, remaining_ends);
1426        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_8);
1427        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(8), 8);
1428        tag_Callouts.ElemName_ends_9 = simd_and(temp, remaining_ends);
1429        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_9);
1430        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(9), 9);
1431        tag_Callouts.ElemName_ends_10 = simd_and(temp, remaining_ends);
1432        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_10);
1433        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(10), 10);
1434        tag_Callouts.ElemName_ends_11 = simd_and(temp, remaining_ends);
1435        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_11);
1436        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(11), 11);
1437        tag_Callouts.ElemName_ends_12 = simd_and(temp, remaining_ends);
1438        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_12);
1439        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(12), 12);
1440        tag_Callouts.ElemName_ends_13 = simd_and(temp, remaining_ends);
1441        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_13);
1442        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(13), 13);
1443        tag_Callouts.ElemName_ends_14 = simd_and(temp, remaining_ends);
1444        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_14);
1445        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(14), 14);
1446        tag_Callouts.ElemName_ends_15 = simd_and(temp, remaining_ends);
1447        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_15);
1448        temp = carryQ.BitBlock_advance_ci_co(temp, carryQ.get_carry_in(15), 15);
1449        tag_Callouts.ElemName_ends_16 = simd_and(temp, remaining_ends);
1450        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_16);
1451        tag_Callouts.ElemName_ends_17_and_longer = remaining_ends;
1452  }
1453  void do_segment(Tag_Callouts tag_Callouts[], int segment_blocks) {
1454  int i;
1455  for (i = 0; i < segment_blocks; i++)
1456    do_block(tag_Callouts[i]);
1457  }
1458  CarryArray<16> carryQ;
1459  };
1460
1461  struct Add_scope_streams {
1462  Add_scope_streams() { 
1463 }
1464  IDISA_INLINE void do_block(Lex & lex, Scope1 & scope1) {
1465                BitBlock v, w, v1, w1;
1466
1467
1468        v = simd_or(lex.LAngle, lex.Hyphen);
1469        w = simd_or(lex.Hyphen, lex.QMark);
1470        v1 = carryQ.BitBlock_advance_ci_co(v, carryQ.get_carry_in(0), 0);
1471        w1 = carryQ.BitBlock_advance_ci_co(w, carryQ.get_carry_in(1), 1);
1472        scope1.LAngle = simd_andc(v1, w1);
1473        scope1.Hyphen = simd_and(v1, w1);
1474        scope1.QMark = simd_andc(w1, v1);
1475        scope1.RefStart = simd<1>::constant<0>();
1476        carryQ.CarryQ_Adjust(2);
1477  }
1478  void do_final_block(Lex & lex, Scope1 & scope1, BitBlock EOF_mask) {
1479                BitBlock v, w, v1, w1;
1480
1481
1482        v = simd_or(lex.LAngle, lex.Hyphen);
1483        w = simd_or(lex.Hyphen, lex.QMark);
1484        v1 = carryQ.BitBlock_advance_ci_co(v, carryQ.get_carry_in(0), 0);
1485        w1 = carryQ.BitBlock_advance_ci_co(w, carryQ.get_carry_in(1), 1);
1486        scope1.LAngle = simd_andc(v1, w1);
1487        scope1.Hyphen = simd_and(v1, w1);
1488        scope1.QMark = simd_andc(w1, v1);
1489        scope1.RefStart = simd<1>::constant<0>();
1490  }
1491  void do_segment(Lex lex[], Scope1 scope1[], int segment_blocks) {
1492  int i;
1493  for (i = 0; i < segment_blocks; i++)
1494    do_block(lex[i], scope1[i]);
1495  }
1496  CarryArray<2> carryQ;
1497  };
1498
1499  struct Compute_Hash_Value_Bitstream {
1500 
1501  IDISA_INLINE void do_block(Hash_data & hash_data, Basis_bits & basis_bits) {
1502
1503
1504
1505        hash_data.Hash_value = simd_xor(simd_xor(basis_bits.bit_2, basis_bits.bit_4), basis_bits.bit_6);
1506  }
1507  void do_final_block(Hash_data & hash_data, Basis_bits & basis_bits, BitBlock EOF_mask) {
1508
1509
1510
1511        hash_data.Hash_value = simd_xor(simd_xor(basis_bits.bit_2, basis_bits.bit_4), basis_bits.bit_6);
1512  }
1513  void do_segment(Hash_data hash_data[], Basis_bits basis_bits[], int segment_blocks) {
1514  int i;
1515  for (i = 0; i < segment_blocks; i++)
1516    do_block(hash_data[i], basis_bits[i]);
1517  }
1518 
1519  };
1520
1521  struct Validate_xml_names {
1522  Validate_xml_names() { 
1523 }
1524  IDISA_INLINE void do_block(CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Tag_Callouts & tag_Callouts, Lex & lex, U8 & u8, Xml_names & xml_names, Check_streams & check_streams) {
1525                BitBlock PI_names, GenRefs, ElemNames, AttNames, qname_stream, ncname_stream;
1526                BitBlock name_stream, name_start, name_cursor, void_prefix_err, namespace_sep;
1527                BitBlock local_part_start, local_part_err, colon2_err, ncname_err;
1528                BitBlock namespace_error;
1529
1530
1531        PI_names = carryQ.BitBlock_sub_ci_co(ctCDPI_Callouts.PI_name_ends, ctCDPI_Callouts.PI_name_starts, carryQ.get_carry_in(0), 0);
1532        GenRefs = carryQ.BitBlock_sub_ci_co(ref_Callouts.GenRef_ends, ref_Callouts.GenRef_starts, carryQ.get_carry_in(1), 1);
1533        ElemNames = carryQ.BitBlock_sub_ci_co(tag_Callouts.ElemName_ends, tag_Callouts.ElemName_starts, carryQ.get_carry_in(2), 2);
1534        AttNames = carryQ.BitBlock_sub_ci_co(tag_Callouts.AttName_ends, tag_Callouts.AttName_starts, carryQ.get_carry_in(3), 3);
1535        qname_stream = simd_or(ElemNames, AttNames);
1536        ncname_stream = simd_or(PI_names, GenRefs);
1537        name_stream = simd_or(qname_stream, ncname_stream);
1538        name_start = simd_andc(name_stream, carryQ.BitBlock_advance_ci_co(name_stream, carryQ.get_carry_in(4), 4));
1539        name_cursor = simd_andc(name_stream, carryQ.BitBlock_advance_ci_co(name_stream, carryQ.get_carry_in(5), 5));
1540        void_prefix_err = simd_and(name_cursor, lex.Colon);
1541        namespace_sep = simd_and(carryQ.BitBlock_scanthru_ci_co(name_cursor, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(6), 6), lex.Colon);
1542        local_part_start = carryQ.BitBlock_advance_ci_co(namespace_sep, carryQ.get_carry_in(7), 7);
1543        local_part_err = simd_andc(local_part_start, lex.NameScan);
1544        colon2_err = simd_and(carryQ.BitBlock_scanthru_ci_co(local_part_start, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(8), 8), lex.Colon);
1545        ncname_err = simd_and(ncname_stream, lex.Colon);
1546        namespace_error = simd_or(simd_or(simd_or(void_prefix_err, local_part_err), colon2_err), ncname_err);
1547        if (bitblock::any(namespace_error)) {
1548          error_tracker.NoteError("error found", namespace_error);
1549        }
1550        check_streams.non_ascii_name_starts = simd_andc(name_start, lex.ASCII_name_start);
1551        check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream, name_start), lex.ASCII_name_char), u8.suffix);
1552        carryQ.CarryQ_Adjust(9);
1553  }
1554  void do_final_block(CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Tag_Callouts & tag_Callouts, Lex & lex, U8 & u8, Xml_names & xml_names, Check_streams & check_streams, BitBlock EOF_mask) {
1555                BitBlock PI_names, GenRefs, ElemNames, AttNames, qname_stream, ncname_stream;
1556                BitBlock name_stream, name_start, name_cursor, void_prefix_err, namespace_sep;
1557                BitBlock local_part_start, local_part_err, colon2_err, ncname_err;
1558                BitBlock namespace_error;
1559
1560
1561        PI_names = carryQ.BitBlock_sub_ci_co(ctCDPI_Callouts.PI_name_ends, ctCDPI_Callouts.PI_name_starts, carryQ.get_carry_in(0), 0);
1562        GenRefs = carryQ.BitBlock_sub_ci_co(ref_Callouts.GenRef_ends, ref_Callouts.GenRef_starts, carryQ.get_carry_in(1), 1);
1563        ElemNames = carryQ.BitBlock_sub_ci_co(tag_Callouts.ElemName_ends, tag_Callouts.ElemName_starts, carryQ.get_carry_in(2), 2);
1564        AttNames = carryQ.BitBlock_sub_ci_co(tag_Callouts.AttName_ends, tag_Callouts.AttName_starts, carryQ.get_carry_in(3), 3);
1565        qname_stream = simd_or(ElemNames, AttNames);
1566        ncname_stream = simd_or(PI_names, GenRefs);
1567        name_stream = simd_or(qname_stream, ncname_stream);
1568        name_start = simd_andc(name_stream, carryQ.BitBlock_advance_ci_co(name_stream, carryQ.get_carry_in(4), 4));
1569        name_cursor = simd_andc(name_stream, carryQ.BitBlock_advance_ci_co(name_stream, carryQ.get_carry_in(5), 5));
1570        void_prefix_err = simd_and(name_cursor, lex.Colon);
1571        namespace_sep = simd_and(carryQ.BitBlock_scanthru_ci_co(name_cursor, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(6), 6), lex.Colon);
1572        local_part_start = carryQ.BitBlock_advance_ci_co(namespace_sep, carryQ.get_carry_in(7), 7);
1573        local_part_err = simd_andc(local_part_start, lex.NameScan);
1574        colon2_err = simd_and(carryQ.BitBlock_scanthru_ci_co(local_part_start, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(8), 8), lex.Colon);
1575        ncname_err = simd_and(ncname_stream, lex.Colon);
1576        namespace_error = simd_or(simd_or(simd_or(void_prefix_err, local_part_err), colon2_err), ncname_err);
1577        if (bitblock::any(namespace_error)) {
1578          error_tracker.NoteError("error found", namespace_error);
1579        }
1580        check_streams.non_ascii_name_starts = simd_andc(name_start, lex.ASCII_name_start);
1581        check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream, name_start), lex.ASCII_name_char), u8.suffix);
1582  }
1583  void do_segment(CtCDPI_Callouts ctCDPI_Callouts[], Ref_Callouts ref_Callouts[], Tag_Callouts tag_Callouts[], Lex lex[], U8 u8[], Xml_names xml_names[], Check_streams check_streams[], int segment_blocks) {
1584  int i;
1585  for (i = 0; i < segment_blocks; i++)
1586    do_block(ctCDPI_Callouts[i], ref_Callouts[i], tag_Callouts[i], lex[i], u8[i], xml_names[i], check_streams[i]);
1587  }
1588  CarryArray<9> carryQ;
1589  };
1590
1591
1592
1593//////////////////////////////////////////////////////////////////////////////////////////
1594// Headers that depend @ global stream struct types.
1595//////////////////////////////////////////////////////////////////////////////////////////
1596#include "../lib/transpose.hpp"
1597#include <post_process.hpp>
1598
1599static void do_process(FILE *infile, FILE *outfile);
1600
1601int main(int argc, char * argv[]) {
1602
1603        char * infilename, * outfilename;
1604        FILE *infile, *outfile;
1605        struct stat fileinfo;
1606
1607        if (argc < 2) {
1608                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
1609                exit(-1);
1610        }
1611
1612        infilename = argv[1];
1613        stat(infilename, &fileinfo);
1614        infile = fopen(infilename, "rb");
1615        if (!infile) {
1616                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
1617                exit(-1);
1618        }
1619
1620        if (argc < 3) outfile = stdout;
1621        else {
1622                outfilename = argv[2];
1623                outfile = fopen(outfilename, "wb");
1624                if (!outfile) {
1625                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
1626                        exit(-1);
1627                }
1628        }
1629
1630        PERF_SEC_BIND(1);
1631
1632        PERF_SEC_INIT(parser_timer);
1633
1634        do_process(infile, outfile);
1635
1636        PERF_SEC_DUMP(parser_timer);
1637
1638        PERF_SEC_DESTROY(parser_timer);
1639
1640        fclose(infile);
1641        fclose(outfile);
1642
1643        return(0);
1644}
1645
1646void do_process(FILE *infile, FILE *outfile) {
1647
1648      struct U8 u8;
1649
1650  struct Lex lex;
1651
1652  struct Scope1 scope1;
1653
1654  struct CtCDPI_Callouts ctCDPI_Callouts;
1655
1656  struct Ref_Callouts ref_Callouts;
1657
1658  struct Hash_data hash_data;
1659
1660  struct Tag_Callouts tag_Callouts;
1661
1662  struct Basis_bits basis_bits;
1663
1664  struct Check_streams check_streams;
1665
1666  struct Xml_names xml_names;
1667
1668  struct Citygml citygml;
1669
1670
1671
1672    LineColTracker tracker;
1673        TagMatcher<SEGMENT_SIZE,LOOKAHEAD_SIZE> matcher;
1674
1675    int block_base=0;
1676        int block_pos = 0;
1677    int buffer_base=0;
1678    int buffer_pos = 0;
1679    int chars_avail = 0;
1680        int chars_read = 0;
1681
1682    //////////////////////////////////////////////////////////////////////////////////////////
1683    // Buffer Management
1684    //////////////////////////////////////////////////////////////////////////////////////////
1685        //      BitBlock buf[(BUFFER_SIZE)/sizeof(BitBlock)];
1686        //      uint8_t * src_buffer = (uint8_t *)buf + COPYBACK_SIZE;
1687
1688        #include "../lib/buffer.hpp"
1689        uint8_t * COPYBACK;
1690        uint8_t * src_buffer;
1691        ALLOC_STATIC_ALIGNED_BYTE_BUFFER_WITH_COPYBACK(COPYBACK, src_buffer);
1692       
1693    //////////////////////////////////////////////////////////////////////////////////////////
1694    // XML Validation / Content Model
1695    //////////////////////////////////////////////////////////////////////////////////////////
1696        chars_read = fread((void *)src_buffer, 1, SEGMENT_SIZE, infile);
1697        chars_avail = chars_read;
1698        if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
1699
1700    if(chars_read<4){
1701                fprintf(stderr,"File is too short. Not well formed.\n");
1702                exit(-1);
1703    }
1704
1705    Entity_Info * e = new Entity_Info;
1706        e->AnalyzeSignature((unsigned char *)src_buffer);
1707
1708    if (e->code_unit_base == ASCII) {
1709
1710                XML_Decl_Parser<ASCII> decl_parser((unsigned char *)src_buffer);
1711
1712                decl_parser.ReadXMLInfo(*e);
1713
1714                if (e->code_unit_size != SingleByte || (e->has_encoding_decl && (!at_UTF_8(e->encoding)))){
1715                        fprintf(stderr,"Sorry, this xmlwf demo only works for UTF-8.\n");
1716                        exit(-1);
1717                }
1718    }
1719    else {
1720        fprintf(stderr,"Sorry, this xmlwf demo does not process EBCDIC.\n");
1721        exit(-1);
1722    }
1723
1724    if (e->content_start != 0) {
1725
1726                memmove(&src_buffer[0], &src_buffer[e->content_start], chars_avail - e->content_start);
1727                buffer_pos = e->content_start;
1728                if ((chars_avail-e->content_start) < SEGMENT_SIZE) {
1729                        chars_read = chars_avail - e->content_start + fread(&src_buffer[chars_avail-e->content_start], 1, e->content_start, infile);
1730                        chars_avail = chars_read;
1731                }
1732                if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
1733    }
1734
1735        //////////////////////////////////////////////////////////////////////////////////////////
1736        // Read OVERLAP bytes to support post processing validation lookahead.
1737        //////////////////////////////////////////////////////////////////////////////////////////
1738        chars_read = chars_avail + fread(&src_buffer[chars_avail], 1, LOOKAHEAD_SIZE, infile);
1739        chars_avail = chars_read;
1740        if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
1741
1742      Parse_refs parse_refs;
1743  Parse_tags parse_tags;
1744  Classify_bytes_Validate_utf8 classify_bytes_Validate_utf8;
1745  Parse_CtCDPI parse_CtCDPI;
1746  Validation_Vec_2 validation_Vec_2;
1747  Do_check_streams do_check_streams;
1748  Form_Length_Group_Bitstreams form_Length_Group_Bitstreams;
1749  Add_scope_streams add_scope_streams;
1750  Compute_Hash_Value_Bitstream compute_Hash_Value_Bitstream;
1751  Validate_xml_names validate_xml_names;
1752
1753
1754    //////////////////////////////////////////////////////////////////////////////////////////
1755    // Full Segments
1756    //////////////////////////////////////////////////////////////////////////////////////////
1757        matcher.setSrc((char *)src_buffer);
1758        while (chars_avail >= SEGMENT_SIZE) {
1759      PERF_SEC_START(parser_timer);
1760      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
1761          block_base = blk*BLOCK_SIZE;
1762                  s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
1763
1764         
1765  classify_bytes_Validate_utf8.do_block(basis_bits, lex, u8);
1766  add_scope_streams.do_block(lex, scope1);
1767  parse_CtCDPI.do_block(ctCDPI_Callouts, lex, scope1, check_streams);
1768  parse_tags.do_block(lex, scope1, ctCDPI_Callouts, tag_Callouts);
1769  parse_refs.do_block(lex, scope1, ctCDPI_Callouts, ref_Callouts);
1770  validate_xml_names.do_block(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, xml_names, check_streams);
1771  do_check_streams.do_block(ctCDPI_Callouts, tag_Callouts, lex, u8, scope1, ref_Callouts, xml_names, check_streams);
1772  form_Length_Group_Bitstreams.do_block(tag_Callouts);
1773  compute_Hash_Value_Bitstream.do_block(hash_data, basis_bits);
1774
1775          tracker.StoreNewlines(lex.LF);
1776                  postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)src_buffer, buffer_base, block_base, chars_avail, tracker);
1777          matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
1778          tracker.AdvanceBlock();
1779      }
1780      matcher.StreamScan(chars_avail);
1781      matcher.Advance_buffer();
1782      PERF_SEC_END(parser_timer, chars_avail);
1783
1784          memmove(src_buffer, &src_buffer[SEGMENT_SIZE], LOOKAHEAD_SIZE); // CopyBack Trailing Padding
1785
1786          // memmove(src_base, &src_buf[SEGMENT_SIZE-COPYBACK_SIZE], COPYBACK_SIZE); // Symbol Table CopyBack
1787          chars_read = fread(&src_buffer[LOOKAHEAD_SIZE], 1, SEGMENT_SIZE, infile) + LOOKAHEAD_SIZE;
1788          chars_avail = chars_read;
1789          if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
1790          buffer_pos += chars_avail;
1791          buffer_base = buffer_pos;
1792    }
1793
1794    //////////////////////////////////////////////////////////////////////////////////////////
1795    // Final Partial Segment
1796    //////////////////////////////////////////////////////////////////////////////////////////
1797    PERF_SEC_START(parser_timer);
1798
1799    block_pos = 0;
1800    int remaining = chars_avail;
1801
1802    /* Full Blocks */
1803    while (remaining >= BLOCK_SIZE) {
1804          block_base = block_pos;
1805                  s2p_do_block((BytePack *) &src_buffer[block_pos], basis_bits);
1806         
1807  classify_bytes_Validate_utf8.do_block(basis_bits, lex, u8);
1808  add_scope_streams.do_block(lex, scope1);
1809  parse_CtCDPI.do_block(ctCDPI_Callouts, lex, scope1, check_streams);
1810  parse_tags.do_block(lex, scope1, ctCDPI_Callouts, tag_Callouts);
1811  parse_refs.do_block(lex, scope1, ctCDPI_Callouts, ref_Callouts);
1812  validate_xml_names.do_block(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, xml_names, check_streams);
1813  do_check_streams.do_block(ctCDPI_Callouts, tag_Callouts, lex, u8, scope1, ref_Callouts, xml_names, check_streams);
1814  form_Length_Group_Bitstreams.do_block(tag_Callouts);
1815  compute_Hash_Value_Bitstream.do_block(hash_data, basis_bits);
1816          tracker.StoreNewlines(lex.LF);
1817                  postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)src_buffer, buffer_base, block_base, chars_avail, tracker);
1818                  matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
1819          tracker.AdvanceBlock();
1820          block_pos += BLOCK_SIZE;
1821          remaining -= BLOCK_SIZE;
1822    }
1823    block_base = block_pos;
1824
1825    /* Partial Block or Any Carry */
1826    if (remaining > 0 || parse_refs.carryQ.CarryTest(0, 6) || parse_tags.carryQ.CarryTest(0, 19) || classify_bytes_Validate_utf8.carryQ.CarryTest(0, 12) || parse_CtCDPI.carryQ.CarryTest(0, 19) || validation_Vec_2.carryQ.CarryTest(0, 1) || form_Length_Group_Bitstreams.carryQ.CarryTest(0, 16) || add_scope_streams.carryQ.CarryTest(0, 2) || validate_xml_names.carryQ.CarryTest(0, 9)) {
1827          EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
1828                  s2p_do_final_block((BytePack *) &src_buffer[block_pos], basis_bits, EOF_mask);
1829         
1830  classify_bytes_Validate_utf8.do_final_block(basis_bits, lex, u8, EOF_mask);
1831  add_scope_streams.do_final_block(lex, scope1, EOF_mask);
1832  parse_CtCDPI.do_final_block(ctCDPI_Callouts, lex, scope1, check_streams, EOF_mask);
1833  parse_tags.do_final_block(lex, scope1, ctCDPI_Callouts, tag_Callouts, EOF_mask);
1834  parse_refs.do_final_block(lex, scope1, ctCDPI_Callouts, ref_Callouts, EOF_mask);
1835  validate_xml_names.do_final_block(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, xml_names, check_streams, EOF_mask);
1836  do_check_streams.do_final_block(ctCDPI_Callouts, tag_Callouts, lex, u8, scope1, ref_Callouts, xml_names, check_streams, EOF_mask);
1837  form_Length_Group_Bitstreams.do_final_block(tag_Callouts, EOF_mask);
1838  compute_Hash_Value_Bitstream.do_final_block(hash_data, basis_bits, EOF_mask);
1839          tracker.StoreNewlines(lex.LF);
1840                  postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)src_buffer, buffer_base, block_base, chars_avail, tracker);
1841          matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
1842          tracker.AdvanceBlock();
1843
1844    }
1845
1846    buffer_pos += chars_avail;
1847    buffer_base = buffer_pos;
1848
1849    matcher.StreamScan(chars_avail);
1850    matcher.Advance_buffer();
1851
1852    if (matcher.depth != 0) {
1853      fprintf(stderr, "tag matching error (depth %i) at position %i\n", matcher.depth, buffer_base);
1854      exit(-1);
1855    }
1856        PERF_SEC_END(parser_timer, chars_avail);
1857}
1858
1859static inline int bitblock_has_bit(BitBlock block){
1860        if (count_forward_zeroes(block) == sizeof(block)*8){
1861                return 0;
1862        }else{
1863                return 1;
1864        }
1865}
1866
1867static inline int ScanBackwardPos(BitBlock * block, int pos, int previous_block_last_elem_start)
1868{
1869    BitBlock s = block[0];
1870    BitBlock temp = simd_and( s, simd_not(simd<128>::sll(simd<1>::constant<1>(), convert(pos))) );
1871
1872    if (bitblock_has_bit(temp))
1873    {
1874        // sizeof (BitBlock)*8 - cbzl( s & ~(~0 << pos)) - 1;
1875        return BLOCK_SIZE - count_reverse_zeroes (temp) - 1;
1876    }
1877    else
1878    {
1879        //handle boundary case
1880        return previous_block_last_elem_start - 1;
1881    }
1882}
1883
1884static inline int compute_hash_value (int lgth, int start)
1885{
1886    unsigned int offset_bit = start + 128;
1887    uint64_t stream = *((uint64_t*)(((uint32_t*)hashvalues)+(offset_bit>>5)));
1888    return stream >> (offset_bit & 0x1F) & ~(~0 << lgth);
1889}
1890
1891static inline char ElemEnd_grouping(int pos) {
1892    int end = block_base + pos;
1893    int start = ScanBackwardPos (&elem_starts, pos,previous_block_last_elem_start) + block_base;
1894    int lgth = end - start;
1895    int hashvalue = compute_hash_value(lgth, start - block_base);
1896    char gid = 0;
1897//    if (lgth >16){
1898//      cout << "length = " << lgth << endl;
1899//      cout << "hashvalue = " << hashvalue << endl;
1900//    }
1901
1902//    if (lgth < 32)
1903//    {
1904//      gid = pbgs_symbol_table.Lookup_or_Insert_Name_32(source + start, hashvalue, lgth);
1905//    }
1906//    else
1907
1908        switch (lgth)
1909    {
1910    case 1:
1911        gid = pbgs_symbol_table.Lookup_or_Insert_Name<1>(source + start, hashvalue);
1912        break;
1913    case 2:
1914        gid = pbgs_symbol_table.Lookup_or_Insert_Name<2>(source + start, hashvalue);
1915        break;
1916    case 3:
1917        gid = pbgs_symbol_table.Lookup_or_Insert_Name<3>(source + start, hashvalue);
1918        break;
1919    case 4:
1920        gid = pbgs_symbol_table.Lookup_or_Insert_Name<4>(source + start, hashvalue);
1921        break;
1922    case 5:
1923        gid = pbgs_symbol_table.Lookup_or_Insert_Name<5>(source + start, hashvalue);
1924        break;
1925    case 6:
1926        gid = pbgs_symbol_table.Lookup_or_Insert_Name<6>(source + start, hashvalue);
1927        break;
1928    case 7:
1929        gid = pbgs_symbol_table.Lookup_or_Insert_Name<7>(source + start, hashvalue);
1930        break;
1931    case 8:
1932        gid = pbgs_symbol_table.Lookup_or_Insert_Name<8>(source + start, hashvalue);
1933        break;
1934    case 9:
1935        gid = pbgs_symbol_table.Lookup_or_Insert_Name<9>(source + start, hashvalue);
1936        break;
1937    case 10:
1938        gid = pbgs_symbol_table.Lookup_or_Insert_Name<10>(source + start, hashvalue);
1939        break;
1940    case 11:
1941        gid = pbgs_symbol_table.Lookup_or_Insert_Name<11>(source + start, hashvalue);
1942        break;
1943    case 12:
1944        gid = pbgs_symbol_table.Lookup_or_Insert_Name<12>(source + start, hashvalue);
1945        break;
1946    case 13:
1947        gid = pbgs_symbol_table.Lookup_or_Insert_Name<13>(source + start, hashvalue);
1948        break;
1949    case 14:
1950        gid = pbgs_symbol_table.Lookup_or_Insert_Name<14>(source + start, hashvalue);
1951        break;
1952    case 15:
1953        gid = pbgs_symbol_table.Lookup_or_Insert_Name<15>(source + start, hashvalue);
1954        break;
1955    case 16:
1956        gid = pbgs_symbol_table.Lookup_or_Insert_Name<16>(source + start, hashvalue);
1957        break;
1958    default:
1959        gid = pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
1960        break;
1961    }
1962/*
1963    {
1964        gid = (char)pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
1965    }
1966*/
1967    gids.push_back(gid);
1968#if DEBUG
1969    char* symbol = new char[lgth+1];
1970    strncpy ( symbol, source + start, lgth );
1971    symbol[lgth] ='\0';
1972    printf ("%s | start: %i[%i] | end: %i[%i] | lgth: %i | hashvalue: %i | gid: %i | symbol: %s\n", __FUNCTION__, start, start - block_base, end, end - block_base, lgth, hashvalue, gid, symbol);
1973#endif
1974        char* symbol = new char[lgth+1];
1975    strncpy ( symbol, source + start, lgth );
1976    symbol[lgth] ='\0';
1977        fprintf(ofile,"%i\t%s\n",gid,symbol); 
1978    return gid;
1979}
1980
1981static inline int StreamScanLengthGrouping(Tag_Callouts & tag_Callouts, int blk_count) {
1982    int blk;
1983    int block_pos = 0;
1984    ScanBlock *stream, *stream2;
1985    stream = (ScanBlock *) &tag_Callouts.ElemName_ends;
1986    stream2 = (ScanBlock *) &tag_Callouts.Tag_closing;
1987    for (blk = 0; blk < blk_count; blk++) {
1988//      if (counter >= 600){
1989//              print_buffer(val_buf,"buffer");
1990//              cout << val_buf_curser << endl;
1991//              cout << "flag = " << content_start_flag << endl;
1992//      }
1993        //cout << "flag = " << content_start_flag << endl;
1994        ScanBlock s = stream[blk];
1995        ScanBlock s2 = stream2[blk];
1996        if (content_start_flag == 1){           //content_start is in the incomming blocks
1997                //cout << "curser=" << val_buf_curser;
1998                //cout << "block_pos=" << block_pos;
1999//              val_double_list(tag_Callouts,-2,block_pos+block_base,blk);
2000                //print_buffer(val_buf,"buffer");
2001        }else if (content_start_flag == -1){            //content_start already occured in the former block
2002                //cout << "curser=" << val_buf_curser;
2003                //cout << "block_pos=" << block_pos;
2004//              val_double_list(tag_Callouts,-1,block_pos+block_base,blk);
2005                //print_buffer(val_buf,"buffer");
2006        }
2007        while(s | s2) {
2008//              cout << "end_pos:"<<s<<endl;
2009//              cout << "end_tag_marks:"<<s2<<endl;
2010            int end_pos = __builtin_ctzll(s) + block_pos;
2011            int end_tag = __builtin_ctzll(s2) + block_pos;
2012//          cout << "count_forward_zeroes(s):" << count_forward_zeroes(s)<<endl;
2013//          cout << "count_forward_zeroes(s2):" << count_forward_zeroes(s2)<<endl;
2014//              cout << (end_tag < end_pos && s2 != 0)<< "||" <<(s == 0 && s2 != 0)  << endl;
2015            if ((end_tag < end_pos && s2 != 0) | (s == 0 && s2 != 0)){
2016//          cout << "closing tag" << endl;
2017//              cout << "endtag:" << end_tag << " " << end_pos<<endl;
2018//              cout << "1"<< endl;
2019//              cout << elem_vec_stack.size()<<endl;
2020//              cout << "2" << endl;
2021//              cout << elem_vec_stack.top()<<endl;
2022                        if (!(*elem_vec_stack.top()).empty()){
2023                                if ((*elem_vec_stack.top()).back() != 0 ){
2024                                        (*elem_vec_stack.top()).push_back(0);   
2025                                }
2026                        }
2027                        elem_vec_stack.pop();
2028//              cout<<"poped\n";
2029                        s2 = s2 & (s2 - 1);
2030                        content_start_flag = 0;
2031            }else{
2032//              cout << " end_pos == " << end_pos<<endl;
2033                char gid = ElemEnd_grouping(end_pos);
2034                // if the gid == 12, the element content is of doublelist type, should do memcpy
2035                if (gid == 13){
2036                        //cout << "gid = 12" << endl; 
2037                        //cout << "curser=" << val_buf_curser<<endl;
2038                        //cout << "block_pos=" << block_pos<<endl;
2039//                      val_double_list(tag_Callouts,end_pos,block_pos+block_base,blk);
2040                        //print_buffer(val_buf,"buffer");
2041                }
2042//              cout << gid << endl;
2043                s = s & (s-1);  // clear rightmost bit.
2044                        if (gid != 0){
2045//                              cout << "gid " << gid<< endl;
2046                                if(elem_vec_map.find(gid) != elem_vec_map.end()){
2047//                                      cout << "found vector" << gid << endl;
2048                                        (*elem_vec_stack.top()).push_back(gid);
2049//                                      cout << "top vector size: " << (*elem_vec_map[gid]).size() << endl;
2050                                        elem_vec_stack.push(elem_vec_map[gid]);
2051//                                      cout << "pushed in" << endl;
2052//                                      cout << "found " << gid << endl;
2053                                }else{
2054//                                      cout << "size :" << elem_vec_stack.size()<<endl;
2055//                                      cout << endl;
2056//                                      cout << elem_vec_stack.top()<<endl;
2057                               
2058//                                      cout << "size before " <<(*elem_vec_stack.top()).size() << endl;
2059                                        (*elem_vec_stack.top()).push_back(gid); 
2060//                                      cout << "size after " <<(*elem_vec_stack.top()).size() << endl;
2061                               
2062                                        vector<char> *tmp = new vector<char>;
2063                                        elem_vec_map[gid] = tmp;
2064                                        elem_vec_stack.push(tmp);
2065                                        //cout << "size after :" << elem_vec_stack.size()<<endl;
2066                                }
2067                        }
2068
2069            }
2070        }
2071        block_pos += 8 * sizeof(ScanBlock);
2072    }
2073    return 0;
2074}
2075
2076static inline void print_vecs(){
2077        int i = 1;
2078        int lst[256] = {0};
2079        cout << elem_vec_map.size() << " vectors" << endl; 
2080        for (int i = 0;i < gids.size(); i++){
2081                if (lst[gids[i]] == 0){
2082                        cout << "gid: " << gids[i] << endl;
2083                        lst[gids[i]] = 1;
2084                        vector<char> *tmp = elem_vec_map[gids[i]];
2085                        cout << "vector size:"<< (*tmp).size()<<endl;
2086                        if ((*tmp).size()!=0){
2087                                cout << "elements: ";
2088                                for (int j = 0; j < (*tmp).size();j++){
2089                                        cout << (int)(*tmp)[j] << " ";
2090                                }
2091                                cout << endl;
2092                        }
2093                        cout << endl;
2094                }
2095        }
2096/*
2097        for(int i = 0;i < gids.size();i++){
2098                cout << " i : " << i << endl;
2099                vector<short int> *tmp = elem_vec_map[gids[i]];
2100                cout << "found" << endl;
2101                cout << "map size:" << elem_vec_map.size()<< endl;
2102                for (map<short int, vector<short int>* >::iterator pos = elem_vec_map.begin(); pos != elem_vec_map.end(); pos++){
2103                        cout << "vector size" << (pos->second)->size() << endl;
2104                }
2105                cout << "size:" << tmp->size()<< endl;
2106               
2107                for (int j = 0;j < tmp->size();j++){
2108                        cout <<tmp[j]<<" ";
2109                }
2110
2111        }
2112*/
2113}
2114
2115
2116static inline void print_elem_vec(vector<char>* vec, int size){
2117        cout << "vector: ";
2118        for (int i = 0; i<size ; i++){
2119                cout << (int)(*vec)[i] <<" ";
2120        }
2121        cout << endl;
2122}
2123
2124static inline void validation_do_block(Lex & lex, Tag_Callouts & tag_Callouts, Hash_data & hash_data, int chars_avail){
2125        elem_starts = tag_Callouts.ElemName_starts_no_ns;
2126//      print_register("starts",tag_Callouts.ElemName_starts_no_ns);
2127//      print_register("ends",tag_Callouts.ElemName_ends);
2128//      print_register("cont start",tag_Callouts.ElemContent_starts);
2129        hashvalues[1] = hash_data.Hash_value;
2130        StreamScanLengthGrouping(tag_Callouts,sizeof(BitBlock)/sizeof(ScanBlock));
2131//      StreamScanLengthGrouping((ScanBlock *) &tag_Callouts.ElemName_ends,(ScanBlock *) &tag_Callouts.Tag_closing, sizeof(BitBlock)/sizeof(ScanBlock));
2132       
2133        previous_block_last_elem_start = - count_reverse_zeroes (elem_starts);
2134//      cout << previous_block_last_elem_start << endl;
2135}
2136
2137static inline void print_basis_bits(Basis_bits & basis_bits){
2138        print_register("bit0:",basis_bits.bit_0);
2139        print_register("bit1:",basis_bits.bit_1);
2140        print_register("bit2:",basis_bits.bit_2);
2141        print_register("bit3:",basis_bits.bit_3);
2142        print_register("bit4:",basis_bits.bit_4);
2143        print_register("bit5:",basis_bits.bit_5);
2144        print_register("bit6:",basis_bits.bit_6);
2145        print_register("bit7:",basis_bits.bit_7);                                       
2146}
2147
2148static inline void validate_city_gml(){
2149        vector<char>* vector_11 = elem_vec_map[2];
2150        cout << "vector_11 size " << (*vector_11).size() << endl;
2151        print_elem_vec(vector_11, (*vector_11).size());
2152        int lgth = (*vector_11).size();
2153        int remaining = 0;
2154        Basis_bits basis_bits;
2155        if (lgth != 0){
2156                int i = 0;
2157                int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
2158                remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
2159                cout << "num_block " << num_block << " remaining " << remaining << endl;
2160                for (i = 0;i < num_block;){
2161//                      s2p_do_block((BytePack*)(vector_11[i]),temp_basis_bits);
2162                        s2p_do_block(((BytePack*)(&(*vector_11)[i])), basis_bits);
2163                        Citygml citygml;
2164                        validation_Vec_2.do_block(citygml, basis_bits);
2165                        print_elem_vec(vector_11,lgth);
2166                        print_basis_bits(basis_bits);
2167//                      (BytePack*)(iter->second)
2168                        i += (BLOCK_SIZE *8 / VECTOR_WIDTH);
2169                        cout << i ;
2170                }
2171                cout << i << endl;
2172                if (remaining !=0){
2173                        EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
2174                        print_register("eof", EOF_mask);
2175                        s2p_do_final_block(((BytePack*)(&(*vector_11)[i])), basis_bits,EOF_mask);
2176                        validation_Vec_2.do_final_block(citygml,basis_bits,EOF_mask);
2177                        print_elem_vec((vector_11)+i,lgth);
2178                        print_basis_bits(basis_bits);
2179                }
2180        }
2181//      print_bit_block("error",error);
2182        cout << "validation vec_11 done" << endl;
2183}
2184
2185
2186
2187
2188static inline void print_streams(char * s1,BitBlock & block,char * name){
2189        int lgth = 2;
2190        int step = 128/lgth;
2191        char tmp[step+1];
2192        char test = s1[0];
2193       
2194        for (int i = 0;i<128;i=i+step){
2195                printf("%20s = ","Source");
2196                for (int j = 0;j<step;j++){
2197                        if (s1[i+j]!='\n' && s1[i+j]!='\r'){
2198                                cout << s1[i+j];
2199                        }else{
2200                                cout << " ";
2201                        }
2202                }
2203                cout << endl;
2204                printf("%20s = ",name);
2205                for (int j = 0;j<step;j++){
2206                        BitBlock temp = simd_and(bitblock::srl(block,convert(i+j)),convert(1));
2207                        if (bitblock::any(temp)){
2208                                cout << 1;
2209                        }else{
2210                                cout << "_";
2211                        }
2212                }
2213                cout << endl;
2214                cout << endl;
2215        }
2216}
2217
2218static inline void print_buffer(char * block, char * name){
2219        int step = 128/2;
2220        char *ptr = (char*)block;
2221        for (int i = 0;i<128;i=i+step){
2222                printf("%20s = ",name);
2223                for (int j = 0;j<step;j++){
2224                        if (ptr[i+j]!='\n' && ptr[i+j]!='\r'){
2225                                cout << ptr[i+j];
2226                        }else{
2227                                cout << " ";
2228                        }
2229                }
2230                cout << endl;
2231               
2232        }
2233        cout << endl;
2234}
2235
2236static inline void val_double_list(Tag_Callouts & tag_Callouts,int elem_end,int block_pos,int blk){
2237        ScanBlock *content_start = (ScanBlock *) &tag_Callouts.ElemContent_starts;
2238        ScanBlock start_blk =content_start[blk];
2239        ScanBlock *content_end = (ScanBlock *) &tag_Callouts.ElemContent_ends;
2240        ScanBlock end_blk = content_end[blk];
2241        int sb_size = sizeof(ScanBlock)*8;
2242        //print_streams(&srcbuf[block_base],tag_Callouts.ElemContent_starts,"elem_content_starts");
2243        //print_streams(&srcbuf[block_base],tag_Callouts.ElemContent_ends,"elem_content_ends");
2244        //cout << "block num = " << blk << endl;
2245        //cout << "elem_end="<<elem_end<<endl<<endl;
2246        //cout << "flag = " << content_start_flag << endl;
2247        if (elem_end == -1){//content_start_pos has occured
2248                if (end_blk == 0){ 
2249                        //print_buffer(val_buf,"buffer");
2250                        if (sb_size < val_buf_avail){
2251                                memcpy(&val_buf[val_buf_curser],source+block_pos,sb_size);
2252                                val_buf_avail -= sb_size;
2253                                val_buf_curser += sb_size;
2254                        }else{
2255                                //cout << "buf_avail = " << val_buf_avail << endl;
2256                                memcpy(&val_buf[val_buf_curser],source+block_pos,val_buf_avail);
2257                                int char_left = sb_size - val_buf_avail;
2258                                val_dl_block();
2259                                memcpy(val_buf,source+block_pos+val_buf_avail, char_left);
2260                                val_buf_avail = sizeof(BitBlock)*8 - char_left;
2261                                val_buf_curser = char_left;
2262                        }
2263                }else{
2264                        //cout << "HHHHHHHHHH" << endl;
2265                        int end_pos = __builtin_ctzll(end_blk);
2266                        //cout << "end_pos = "<<end_pos << endl;
2267                        //cout <<"buf_avail = "<<val_buf_avail<<endl;
2268                        if (end_pos > val_buf_avail){
2269                                memcpy(&val_buf[val_buf_curser],source+block_pos,val_buf_avail);
2270                                int char_left = end_pos - val_buf_avail;
2271                                val_dl_block();
2272                                if (char_left != 0){
2273                                        memcpy(val_buf,source+block_pos+val_buf_avail, char_left);
2274                                }
2275                                val_buf_avail = sizeof(BitBlock)*8 - char_left;
2276                                val_buf_curser = char_left;
2277                        }else{
2278                                memcpy(&val_buf[val_buf_curser],source+block_pos,end_pos);
2279                                //cout <<"source "<< source[block_pos]<<source[block_pos+1]<<source[block_pos+2]<<endl;
2280                                val_buf_avail = val_buf_avail - end_pos;
2281                                val_buf_curser = val_buf_curser + end_pos;
2282                        }
2283                        content_start_flag = 0;
2284                        //print_buffer(val_buf,"buffer");
2285                        //cout << "s = " << sizeof(val_buf) << endl;
2286                        //cout << "curser = " << val_buf_curser << endl;
2287                }
2288        }else if(elem_end == -2){
2289                if (start_blk != 0){
2290                        int start_pos = __builtin_ctzll(start_blk);
2291                        int end_pos = 0;
2292                        if (end_blk == 0){
2293                                end_pos = sb_size;
2294                        }else{
2295                                end_pos = __builtin_ctzll(end_blk);
2296                        //cout << "s_p:e_p" << start_pos << " " << end_pos << endl;
2297                                while(end_pos < start_pos){
2298                                        end_blk = end_blk & (end_blk - 1);
2299                                        end_pos = __builtin_ctzll(end_blk);
2300                                }
2301                        }
2302                        //cout << "s_p:e_p" << start_pos << " " << end_pos << endl;
2303                        int char_left = end_pos - start_pos;
2304                        //cout << "buf_avail " << val_buf_avail<< endl;
2305                        //cout << "char left " << char_left << endl;
2306                        if (val_buf_avail > char_left){
2307                                memcpy(&val_buf[val_buf_curser],source+block_pos+start_pos,char_left);
2308                                val_buf_avail = val_buf_avail - char_left;
2309                                val_buf_curser = val_buf_curser + char_left;
2310                        }else{
2311                                memcpy(&val_buf[val_buf_curser],source+block_pos+start_pos,val_buf_avail);
2312                                val_dl_block();
2313                                char_left -= val_buf_avail;
2314                                val_buf_avail = sb_size - char_left + val_buf_avail;
2315                                if (char_left != 0){
2316                                        memcpy(val_buf,source+block_pos+start_pos+ val_buf_avail,char_left);
2317                                }
2318                                val_buf_curser = char_left;
2319                        }
2320                        if (end_pos != sb_size){
2321                                content_start_flag = 0;
2322                        }else{
2323                                content_start_flag = -1;
2324                        }                       
2325                }else{
2326                        content_start_flag = 1;
2327                        return;
2328                }
2329                //print_buffer(val_buf,"buffer");
2330        }else{
2331                //cout << "buf_avail " << val_buf_avail<< endl;
2332                if (start_blk == 0){
2333                        content_start_flag = 1;
2334                        return;
2335                }else{
2336                        //cout << "#curser=" << val_buf_curser<<endl;
2337                        //cout << "#block_pos=" << block_pos<<endl;
2338                        int start_pos = __builtin_ctzll(start_blk);
2339                        while(start_pos <= elem_end){                           //?
2340                                start_blk = start_blk & (start_blk -1);
2341                                start_pos = __builtin_ctzll(start_blk);
2342                        }
2343                        if (start_pos == sb_size){
2344                                content_start_flag = -1;
2345                                return;
2346                        }
2347                        int end_pos = 0;
2348                        if (end_blk == 0){
2349                                end_pos = sb_size;
2350                        }else{
2351                                end_pos = __builtin_ctzll(end_blk);
2352                                while(end_pos < start_pos){
2353                                        end_blk = end_blk & (end_blk - 1);
2354                                        end_pos = __builtin_ctzll(end_blk);
2355                                }
2356                        }
2357                        int char_left = end_pos - start_pos;
2358                        if (val_buf_avail > char_left){
2359                                memcpy(&val_buf[val_buf_curser],source+block_pos+start_pos,char_left);
2360                                val_buf_avail = val_buf_avail - char_left;
2361                                val_buf_curser = val_buf_curser + char_left;
2362                        }else{
2363                                memcpy(&val_buf[val_buf_curser],source+block_pos+start_pos,val_buf_avail);
2364                                val_dl_block();
2365                                char_left -= val_buf_avail;
2366                                val_buf_avail = sb_size - char_left + val_buf_avail;
2367                                val_buf_curser = 0;
2368                                if(char_left != 0){
2369                                        memcpy(val_buf,source+block_pos+start_pos+ val_buf_avail,char_left);
2370                                }
2371                                val_buf_curser = char_left;
2372                        }
2373                        if (end_pos == sb_size){
2374                                content_start_flag = 1;
2375                        }
2376                        //cout << "start" << start_pos << endl;
2377                        //print_buffer(val_buf,"buffer");
2378                }
2379        }
2380}
2381
2382static inline void val_dl_block(){
2383        print_buffer(val_buf,"buffer");
2384        //cout << "vvvvvvvvvvvvvvv"<< endl;
2385}
2386
2387
Note: See TracBrowser for help on using the repository browser.