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

Last change on this file since 2351 was 2351, checked in by ksherdy, 7 years ago

Updated #includes.

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