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

Last change on this file since 3541 was 3541, checked in by shiyangy, 6 years ago

perf script added

File size: 169.9 KB
Line 
1
2#include <simd-lib/bitblock.hpp>
3#include <simd-lib/carryQ.hpp>
4#include <simd-lib/pabloSupport.hpp>
5
6#define LocalCarryDeclare(name, count)\
7CarryArray<count, 0> name;\
8
9#define assert_0_error(errkind, errstrm)
10
11BitBlock EOF_mask = simd<1>::constant<1>();
12
13//#define USE_FUNCTION_TEMPLATES
14//#define TEMPLATED_SIMD_LIB
15
16//#define BLOCK_SIZE (sizeof(SIMD_type) * 8)
17//#define SEGMENT_BLOCKS 12
18//#define BUFFER_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
19//#define OVERLAP_BUFSIZE 2*(sizeof(SIMD_type))
20
21#define VECTOR_WIDTH 8
22#define VECTOR_TYPE (char)
23
24#define DEBUG 1
25
26//#define DATATYPE 1
27
28//#define CONTENT_MODEL 1
29
30//#define SYMBOL_TABLE 1
31
32int Datatype = 0;
33int Content_model = 0;
34int Symbol = 0;
35int Data_gather = 0;
36int Content_gather = 0;
37
38
39#include <stdio.h>
40#include <stdlib.h>
41#include <errno.h>
42#include <sys/types.h>
43#include <sys/stat.h>
44#include <limits.h>
45
46#include <simd-lib/s2p.hpp>
47#include <simd-lib/buffer.hpp>
48#include <simd-lib/bitblock_iterator.hpp>
49#include <simd-lib/perflib/perfsec.h>
50
51//#include "../lib/lib_simd.h"
52#include "../symtab/pbgs_identity_symbol_table.h"
53
54#include <stack>
55#include <map>
56#include <vector>
57
58#include <queue>
59#include <string>
60
61typedef long ScanBlock;
62typedef BytePack BitBlock;
63
64using namespace std;
65
66//#include "../lib/carryQ.h"
67#include <xmldecl.h>
68//#include "xml_error.c"
69//#include "xmldecl.c"
70#include <namechars.h>
71#include <LineColTracker.hpp>
72#include <XMLTestSuiteError.h>
73
74// Define the mappings for pablo.assert_0(strm, errkind) statements which
75// compile to the the form assert_0_error(errkind, strm)
76#include <ErrorTracker.h>
77
78ErrorTracker error_tracker;
79#define assert_0_error(errkind, errstrm) error_tracker.NoteError(errkind, errstrm);
80
81#ifndef STL_ALIGNED_VECTOR
82#include <TagMatcher.hpp>
83#endif
84
85#ifdef STL_ALIGNED_VECTOR // experimental, comment out TagMatcher code to use STL aligned memory vector
86#warning "Compiling with experimental STL_ALIGNED_VECTOR."
87#include <vector>
88#include <simd-lib/stl_aligned_allocator.hpp>
89#endif
90
91#ifdef BUFFER_PROFILING
92    BOM_Table * parser_timer;
93#elif PAPI
94                #define PAPI_EVENTS_COUNT 2
95                int PAPI_EVENTS[PAPI_EVENTS_COUNT] = {PAPI_TOT_CYC, PAPI_BR_MSP};       
96    CC * parser_timer;
97#else
98    void * parser_timer;
99#endif
100
101//////////////////////////////////////////////////////////////////////////////////////////
102// Buffer Management // WARNING: Do Not update #defines. Results in TagMatcher errors.
103//////////////////////////////////////////////////////////////////////////////////////////
104#define PADDING_BLOCKS 0
105#define PADDING_SIZE (BLOCK_SIZE * PADDING_BLOCKS)
106#define COPYBACK_BLOCKS 2
107#define COPYBACK_SIZE (BLOCK_SIZE * COPYBACK_BLOCKS)
108#define LOOKAHEAD_BLOCKS 1
109#define LOOKAHEAD_SIZE (BLOCK_SIZE * LOOKAHEAD_BLOCKS)
110#define SEGMENT_BLOCKS  12 // WARNING: TagMatcher.hpp causes xmlconf test suite failures for SEGMENT_BLOCKS < 3.
111#define SEGMENT_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
112#define BUFFER_SIZE (COPYBACK_SIZE + SEGMENT_SIZE + LOOKAHEAD_SIZE + PADDING_SIZE)
113
114
115
116//int block_base=0;
117//int buffer_base=0;
118int buffer_last;
119FILE *gid_writein;
120#define ELEMENT_BUFFER_SIZE 30
121char element_name_buffer[ELEMENT_BUFFER_SIZE];
122int cross_buffer_flag = 0;
123//char * source;
124LineColTracker tracker;
125
126#define CONTENT_BUFFER_SIZE BLOCK_SIZE
127char content_buffer[CONTENT_BUFFER_SIZE];
128char content_lookahead_buffer[CONTENT_BUFFER_SIZE];
129int content_buffer_pos = 0;
130int content_carry = 0;
131char gid;
132int content_start_carry = 0;
133
134#define CONTENT_INDEX 13
135
136static inline int cfzl(long x) { if (x == 0) return sizeof(long)*8; else return __builtin_ctzl(x);}
137/*
138static inline int cfzl(long x){
139        unsigned long ux = x;
140        if (x<0){
141                ux = ULONG_MAX + x + 1;
142        }
143        if (ux==0)
144                return 8*sizeof(long);
145        int n;
146        n = 0;
147        while (1){
148                if ((ux%2) == 1){
149                        if(n==64){
150//                              cout << ux <<endl;
151                        }
152                        return n;               
153                }
154                n ++;
155                ux = ux >> 1;
156                //cout << "x = " << x << endl;
157        }
158}
159*/
160static inline void print_gid_vec();
161/*
162static inline int cfzl(long x){
163 if (x ==0)
164  return 32;
165 int n=0;
166 if ((x & 0xFFFF0000) == 0) { n += 16; x =x << 16;} //1111 1111 1111 1111 0000 0000 0000 0000 // 16 bits from left are zero! so we omit 16left bits
167 if ((x & 0xFF000000) == 0){ n = n +  8; x = x <<  8;} // 8 left bits are 0
168 if ((x & 0xF0000000) ==0){ n = n +  4; x = x <<  4;} // 4 left bits are 0
169 if ((x & 0xC0000000) == 0){ n =n +  2, x = x <<  2;}  // 110000....0 2 left bits are zero
170 if ((x & 0x80000000) == 0){n = n +  1, x = x <<  1;} // first left bit is zero
171 return n;
172
173}
174*/
175static inline void ReportError(const char * error_msg, int error_pos_in_block) {
176  int error_line, error_column;
177  tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
178  fprintf(stderr, "%s at line %i, column %i\n", error_msg, error_line, error_column);
179}
180/*
181class ErrorTracker {
182public:
183    ErrorTracker() { noted_pos_in_block = -1;}
184
185    inline void NoteError(const char * error_msg, BitBlock err_strm) {
186      int pos_in_block = count_forward_zeroes(err_strm);
187      if ((noted_pos_in_block == -1) || (noted_pos_in_block > pos_in_block)) {
188        noted_pos_in_block = pos_in_block;
189        noted_error = error_msg;
190      }
191    }
192
193    inline void If_Error_Report_First() {
194      if (noted_pos_in_block > -1) {
195              int error_line, error_column;
196              ReportError(noted_error, noted_pos_in_block);
197              exit(-1);
198      }
199    }
200
201private:
202  const char * noted_error;
203  int noted_pos_in_block;
204};
205*/
206
207
208//BitBlock EOF_mask = simd_const_1(1);
209
210//ErrorTracker error_tracker;
211BitBlock elem_starts;
212int previous_block_last_elem_start;
213BytePack hashvalues[2];
214
215vector <int> gids;
216PBGSIdentitySymbolTable pbgs_symbol_table;
217
218#define MAX_COUNT 128
219vector <char> gid_vec[MAX_COUNT];
220int current_depth = 0;
221vector <int> pre_index;
222
223stack <vector<char>* > elem_vec_stack;
224map<char, vector<char>* > elem_vec_map;
225
226  struct U8 {
227  BitBlock unibyte;
228  BitBlock prefix;
229  BitBlock prefix2;
230  BitBlock prefix3;
231  BitBlock prefix4;
232  BitBlock suffix;
233  BitBlock badprefix;
234  BitBlock xE0;
235  BitBlock xED;
236  BitBlock xF0;
237  BitBlock xF4;
238  BitBlock xA0_xBF;
239  BitBlock x80_x9F;
240  BitBlock x90_xBF;
241  BitBlock x80_x8F;
242  BitBlock xEF;
243  BitBlock xBF;
244  BitBlock xBE;
245  BitBlock scope22;
246  BitBlock scope32;
247  BitBlock scope33;
248  BitBlock scope42;
249  BitBlock scope43;
250  BitBlock scope44;
251  BitBlock xE0_scope;
252  BitBlock xED_scope;
253  BitBlock xF0_scope;
254  BitBlock xF4_scope;
255  BitBlock xEF_scope;
256};
257
258  struct Lex {
259  BitBlock CR;
260  BitBlock LF;
261  BitBlock HT;
262  BitBlock SP;
263  BitBlock CRLF;
264  BitBlock RefStart;
265  BitBlock Semicolon;
266  BitBlock Colon;
267  BitBlock LAngle;
268  BitBlock RAngle;
269  BitBlock LBracket;
270  BitBlock RBracket;
271  BitBlock Exclam;
272  BitBlock QMark;
273  BitBlock Hyphen;
274  BitBlock Equals;
275  BitBlock SQuote;
276  BitBlock DQuote;
277  BitBlock Slash;
278  BitBlock Hash;
279  BitBlock x;
280  BitBlock ASCII_name_start;
281  BitBlock ASCII_name_char;
282  BitBlock NameScan;
283  BitBlock Digit;
284  BitBlock Hex;
285  BitBlock WS;
286  BitBlock tag_closing;
287  BitBlock cc0;
288  BitBlock Caret;
289  BitBlock Dot;
290  BitBlock P_H_sign;
291  BitBlock E_and_e;
292  BitBlock content_end;
293  BitBlock cc1;
294  BitBlock cc2;
295  BitBlock cc3;
296  BitBlock cc4;
297  BitBlock cc5;
298  BitBlock cc6;
299  BitBlock cc7;
300  BitBlock cc8;
301  BitBlock cc9;
302  BitBlock cc10;
303  BitBlock cc11;
304  BitBlock cc12;
305  BitBlock cc13;
306};
307
308  struct Scope1 {
309  BitBlock RefStart;
310  BitBlock LAngle;
311  BitBlock Hyphen;
312  BitBlock QMark;
313  BitBlock RBracket;
314};
315
316  struct Marker {
317  BitBlock LAngle_scope;
318  BitBlock Ref_opener;
319  BitBlock CD_closer;
320};
321
322  struct CtCDPI_Callouts {
323  BitBlock CD_end;
324  BitBlock Ct_starts;
325  BitBlock Ct_ends;
326  BitBlock CD_starts;
327  BitBlock CD_ends;
328  BitBlock PI_starts;
329  BitBlock PI_name_starts;
330  BitBlock PI_name_ends;
331  BitBlock PI_ends;
332  BitBlock CtCDPI_mask;
333};
334
335  struct Ref_Callouts {
336  BitBlock GenRef_starts;
337  BitBlock GenRef_ends;
338  BitBlock DecRef_starts;
339  BitBlock DecRef_ends;
340  BitBlock HexRef_starts;
341  BitBlock HexRef_ends;
342};
343
344  struct Hash_data {
345  BitBlock Hash_value;
346};
347
348  struct Tag_Callouts {
349  BitBlock ElemName_starts;
350  BitBlock ElemName_ends;
351  BitBlock ElemName_ends_1;
352  BitBlock ElemName_ends_2;
353  BitBlock ElemName_ends_3;
354  BitBlock ElemName_ends_4;
355  BitBlock ElemName_ends_5;
356  BitBlock ElemName_ends_6;
357  BitBlock ElemName_ends_7;
358  BitBlock ElemName_ends_8;
359  BitBlock ElemName_ends_9;
360  BitBlock ElemName_ends_10;
361  BitBlock ElemName_ends_11;
362  BitBlock ElemName_ends_12;
363  BitBlock ElemName_ends_13;
364  BitBlock ElemName_ends_14;
365  BitBlock ElemName_ends_15;
366  BitBlock ElemName_ends_16;
367  BitBlock ElemName_ends_17_and_longer;
368  BitBlock AttName_starts;
369  BitBlock AttName_ends;
370  BitBlock AttVal_starts;
371  BitBlock AttVal_ends;
372  BitBlock AttVal_spans;
373  BitBlock EmptyTag_marks;
374  BitBlock EndTag_marks;
375  BitBlock Content_starts;
376  BitBlock Tag_closing;
377};
378
379  struct Basis_bits {
380  BitBlock bit_0;
381  BitBlock bit_1;
382  BitBlock bit_2;
383  BitBlock bit_3;
384  BitBlock bit_4;
385  BitBlock bit_5;
386  BitBlock bit_6;
387  BitBlock bit_7;
388};
389
390  struct Check_streams {
391  BitBlock misc_mask;
392  BitBlock non_ascii_name_starts;
393  BitBlock non_ascii_names;
394  BitBlock tag_marks;
395  BitBlock name_follows;
396  BitBlock att_refs;
397};
398
399  struct Xml_names {
400  BitBlock namespace_error;
401};
402
403  struct Elem {
404  BitBlock purchaseOrder;
405  BitBlock shipTo;
406  BitBlock name;
407  BitBlock street;
408  BitBlock city;
409  BitBlock state;
410  BitBlock zip;
411  BitBlock billTo;
412  BitBlock comment;
413  BitBlock items;
414  BitBlock item;
415  BitBlock productName;
416  BitBlock quantity;
417  BitBlock USPrice;
418  BitBlock shipDate;
419};
420
421  struct Output {
422  BitBlock matches;
423  BitBlock tem;
424};
425
426  struct Parse_refs {
427  Parse_refs() { 
428 }
429  IDISA_INLINE void do_block(Lex & lex, Marker & marker, Ref_Callouts & ref_Callouts) {
430                BitBlock ref_error, Ref_scope, NumRef2, NumRef3, HexRef3, ref_error1;
431                BitBlock ref_error2, ref_ends, ref_error3;
432
433
434
435
436        ref_Callouts.GenRef_starts = simd<1>::constant<0>();
437        ref_Callouts.GenRef_ends = simd<1>::constant<0>();
438        ref_Callouts.DecRef_starts = simd<1>::constant<0>();
439        ref_Callouts.DecRef_ends = simd<1>::constant<0>();
440        ref_Callouts.HexRef_starts = simd<1>::constant<0>();
441        ref_Callouts.HexRef_ends = simd<1>::constant<0>();
442        ref_error = simd<1>::constant<0>();
443        if ((bitblock::any(marker.Ref_opener) || carryQ.CarryTest(0, 6))) {
444          carryQ.cq[0] = carryout2carry(pablo_blk_Advance(marker.Ref_opener, carryQ.get_carry_in(0), Ref_scope));
445          NumRef2 = simd_and(Ref_scope, lex.Hash);
446          ref_Callouts.GenRef_starts = simd_andc(Ref_scope, lex.Hash);
447          carryQ.cq[1] = carryout2carry(pablo_blk_Advance(NumRef2, carryQ.get_carry_in(1), NumRef3));
448          HexRef3 = simd_and(NumRef3, lex.x);
449          ref_Callouts.DecRef_starts = simd_andc(NumRef3, lex.x);
450          carryQ.cq[2] = carryout2carry(pablo_blk_Advance(HexRef3, carryQ.get_carry_in(2), ref_Callouts.HexRef_starts));
451          carryQ.cq[3] = carryout2carry(pablo_blk_ScanThru(ref_Callouts.GenRef_starts, lex.NameScan, carryQ.get_carry_in(3), ref_Callouts.GenRef_ends));
452          carryQ.cq[4] = carryout2carry(pablo_blk_ScanThru(ref_Callouts.DecRef_starts, lex.Digit, carryQ.get_carry_in(4), ref_Callouts.DecRef_ends));
453          carryQ.cq[5] = carryout2carry(pablo_blk_ScanThru(ref_Callouts.HexRef_starts, lex.Hex, carryQ.get_carry_in(5), ref_Callouts.HexRef_ends));
454          ref_error1 = simd_andc(ref_Callouts.DecRef_starts, lex.Digit);
455          ref_error2 = simd_andc(ref_Callouts.HexRef_starts, lex.Hex);
456          ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
457          ref_error3 = simd_andc(ref_ends, lex.Semicolon);
458          if (bitblock::any(simd_or(simd_or(ref_error1, ref_error2), ref_error3))) {
459            assert_0_error("Reference error found", simd_or(simd_or(ref_error1, ref_error2), ref_error3));
460          }
461        }
462        else {
463          carryQ.CarryDequeueEnqueue(0, 6);
464        }
465        carryQ.CarryQ_Adjust(6);
466  }
467  IDISA_INLINE void clear() { 
468 }
469  void do_final_block(Lex & lex, Marker & marker, Ref_Callouts & ref_Callouts, BitBlock EOF_mask) {
470                BitBlock ref_error, Ref_scope, NumRef2, NumRef3, HexRef3, ref_error1;
471                BitBlock ref_error2, ref_ends, ref_error3;
472
473
474
475
476        ref_Callouts.GenRef_starts = simd<1>::constant<0>();
477        ref_Callouts.GenRef_ends = simd<1>::constant<0>();
478        ref_Callouts.DecRef_starts = simd<1>::constant<0>();
479        ref_Callouts.DecRef_ends = simd<1>::constant<0>();
480        ref_Callouts.HexRef_starts = simd<1>::constant<0>();
481        ref_Callouts.HexRef_ends = simd<1>::constant<0>();
482        ref_error = simd<1>::constant<0>();
483        if ((bitblock::any(marker.Ref_opener) || carryQ.CarryTest(0, 6))) {
484          carryQ.cq[0] = carryout2carry(pablo_blk_Advance(marker.Ref_opener, carryQ.get_carry_in(0), Ref_scope));
485          NumRef2 = simd_and(Ref_scope, lex.Hash);
486          ref_Callouts.GenRef_starts = simd_andc(Ref_scope, lex.Hash);
487          carryQ.cq[1] = carryout2carry(pablo_blk_Advance(NumRef2, carryQ.get_carry_in(1), NumRef3));
488          HexRef3 = simd_and(NumRef3, lex.x);
489          ref_Callouts.DecRef_starts = simd_andc(NumRef3, lex.x);
490          carryQ.cq[2] = carryout2carry(pablo_blk_Advance(HexRef3, carryQ.get_carry_in(2), ref_Callouts.HexRef_starts));
491          carryQ.cq[3] = carryout2carry(pablo_blk_ScanThru(ref_Callouts.GenRef_starts, lex.NameScan, carryQ.get_carry_in(3), ref_Callouts.GenRef_ends));
492          carryQ.cq[4] = carryout2carry(pablo_blk_ScanThru(ref_Callouts.DecRef_starts, lex.Digit, carryQ.get_carry_in(4), ref_Callouts.DecRef_ends));
493          carryQ.cq[5] = carryout2carry(pablo_blk_ScanThru(ref_Callouts.HexRef_starts, lex.Hex, carryQ.get_carry_in(5), ref_Callouts.HexRef_ends));
494          ref_error1 = simd_andc(ref_Callouts.DecRef_starts, lex.Digit);
495          ref_error2 = simd_andc(ref_Callouts.HexRef_starts, lex.Hex);
496          ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
497          ref_error3 = simd_andc(ref_ends, lex.Semicolon);
498          if (bitblock::any(simd_or(simd_or(ref_error1, ref_error2), ref_error3))) {
499            assert_0_error("Reference error found", simd_or(simd_or(ref_error1, ref_error2), ref_error3));
500          }
501        }
502        else {
503          carryQ.CarryDequeueEnqueue(0, 6);
504        }
505  }
506  CarryArray<6, 0> carryQ;
507  };
508
509  struct Parse_tags {
510  Parse_tags() { 
511 }
512  IDISA_INLINE void do_block(Lex & lex, Marker & marker, Tag_Callouts & tag_Callouts) {
513                BitBlock EqExpected, AttListEnd, DQuoteDelim, SQuoteDelim, AttListDelim;
514                BitBlock ParseError, AfterWS, AttNameStart, AttNameFollow, AttValPos;
515                BitBlock DQuoteAttVal, SQuoteAttVal, DQuoteAttEnd, SQuoteAttEnd, AttValEnd;
516                BitBlock AttValFollow, STagEnds, EndTagEnds;
517
518
519
520
521        EqExpected = simd<1>::constant<0>();
522        AttListEnd = simd<1>::constant<0>();
523        DQuoteDelim = simd_or(lex.DQuote, lex.LAngle);
524        SQuoteDelim = simd_or(lex.SQuote, lex.LAngle);
525        AttListDelim = simd_or(lex.Slash, lex.RAngle);
526        tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope, lex.Slash);
527        tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope, lex.Slash);
528        carryQ.cq[0] = carryout2carry(pablo_blk_ScanThru(tag_Callouts.ElemName_starts, lex.NameScan, carryQ.get_carry_in(0), tag_Callouts.ElemName_ends));
529        ParseError = simd_and(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
530        tag_Callouts.AttName_starts = simd<1>::constant<0>();
531        tag_Callouts.AttName_ends = simd<1>::constant<0>();
532        tag_Callouts.AttVal_starts = simd<1>::constant<0>();
533        tag_Callouts.AttVal_ends = simd<1>::constant<0>();
534        if ((bitblock::any(simd_and(tag_Callouts.ElemName_ends, lex.WS)) || carryQ.CarryTest(1, 8))) {
535          carryQ.cq[1] = carryout2carry(pablo_blk_ScanThru(tag_Callouts.ElemName_ends, lex.WS, carryQ.get_carry_in(1), AfterWS));
536          AttListEnd = simd_and(AfterWS, AttListDelim);
537          AttNameStart = simd_andc(AfterWS, AttListDelim);
538          if ((bitblock::any(AttNameStart) || carryQ.CarryTest(2, 7))) {
539            ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
540            tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
541            carryQ.cq[2] = carryout2carry(pablo_blk_ScanThru(AttNameStart, lex.NameScan, carryQ.get_carry_in(2), AttNameFollow));
542            tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
543            if ((bitblock::any(simd_and(AttNameFollow, lex.WS)) || carryQ.CarryTest(3, 1))) {
544              carryQ.cq[3] = carryout2carry(pablo_blk_ScanThru(AttNameFollow, lex.WS, carryQ.get_carry_in(3), EqExpected));
545            }
546            else {
547              EqExpected = AttNameFollow;
548              carryQ.CarryDequeueEnqueue(3, 1);
549            }
550            ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
551            carryQ.cq[4] = carryout2carry(pablo_blk_AdvanceThenScanThru(EqExpected, lex.WS, carryQ.get_carry_in(4), AttValPos));
552            tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
553            DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
554            SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
555            carryQ.cq[5] = carryout2carry(pablo_blk_AdvanceThenScanThru(DQuoteAttVal, simd_not(DQuoteDelim), carryQ.get_carry_in(5), DQuoteAttEnd));
556            carryQ.cq[6] = carryout2carry(pablo_blk_AdvanceThenScanThru(SQuoteAttVal, simd_not(SQuoteDelim), carryQ.get_carry_in(6), SQuoteAttEnd));
557            AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
558            ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
559            carryQ.cq[7] = carryout2carry(pablo_blk_Advance(AttValEnd, carryQ.get_carry_in(7), AttValFollow));
560            tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
561            if ((bitblock::any(simd_and(AttValFollow, lex.WS)) || carryQ.CarryTest(8, 1))) {
562              carryQ.cq[8] = carryout2carry(pablo_blk_ScanThru(AttValFollow, lex.WS, carryQ.get_carry_in(8), AfterWS));
563              AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
564              AttNameStart = simd_andc(AfterWS, AttListDelim);
565            }
566            else {
567              AttListEnd = simd_or(AttListEnd, simd_and(AttValFollow, AttListDelim));
568              AttNameStart = simd_andc(AttValFollow, AttListDelim);
569              carryQ.CarryDequeueEnqueue(8, 1);
570            }
571            ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
572            while (bitblock::any(AttNameStart)) {
573              LocalCarryDeclare(subcarryQ, 7);
574              ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
575              tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
576              subcarryQ.cq[0] = carryout2carry(pablo_blk_ScanThru(AttNameStart, lex.NameScan, carry_value_0, AttNameFollow));
577              tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
578              if (bitblock::any(simd_and(AttNameFollow, lex.WS))) {
579                subcarryQ.cq[1] = carryout2carry(pablo_blk_ScanThru(AttNameFollow, lex.WS, carry_value_0, EqExpected));
580              }
581              else {
582                EqExpected = AttNameFollow;
583                subcarryQ.CarryDequeueEnqueue(3, 1);
584              }
585              ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
586              subcarryQ.cq[2] = carryout2carry(pablo_blk_AdvanceThenScanThru(EqExpected, lex.WS, carry_value_0, AttValPos));
587              tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
588              DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
589              SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
590              subcarryQ.cq[3] = carryout2carry(pablo_blk_AdvanceThenScanThru(DQuoteAttVal, simd_not(DQuoteDelim), carry_value_0, DQuoteAttEnd));
591              subcarryQ.cq[4] = carryout2carry(pablo_blk_AdvanceThenScanThru(SQuoteAttVal, simd_not(SQuoteDelim), carry_value_0, SQuoteAttEnd));
592              AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
593              ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
594              subcarryQ.cq[5] = carryout2carry(pablo_blk_Advance(AttValEnd, carry_value_0, AttValFollow));
595              tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
596              if (bitblock::any(simd_and(AttValFollow, lex.WS))) {
597                subcarryQ.cq[6] = carryout2carry(pablo_blk_ScanThru(AttValFollow, lex.WS, carry_value_0, AfterWS));
598                AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
599                AttNameStart = simd_andc(AfterWS, AttListDelim);
600              }
601              else {
602                AttListEnd = simd_or(AttListEnd, simd_and(AttValFollow, AttListDelim));
603                AttNameStart = simd_andc(AttValFollow, AttListDelim);
604                subcarryQ.CarryDequeueEnqueue(8, 1);
605              }
606              ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
607              carryQ.CarryCombine(subcarryQ.cq, 2, 7);
608            }
609          }
610          else {
611            carryQ.CarryDequeueEnqueue(2, 7);
612          }
613        }
614        else {
615          AttListEnd = simd_and(tag_Callouts.ElemName_ends, AttListDelim);
616          ParseError = simd_or(ParseError, simd_andc(tag_Callouts.ElemName_ends, AttListDelim));
617          carryQ.CarryDequeueEnqueue(1, 8);
618        }
619        STagEnds = simd_and(AttListEnd, lex.RAngle);
620        carryQ.cq[9] = carryout2carry(pablo_blk_Advance(simd_and(AttListEnd, lex.Slash), carryQ.get_carry_in(9), tag_Callouts.EmptyTag_marks));
621        ParseError = simd_or(ParseError, simd_andc(tag_Callouts.EmptyTag_marks, lex.RAngle));
622        carryQ.cq[10] = carryout2carry(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks, lex.NameScan, carryQ.get_carry_in(10), EndTagEnds));
623        if ((bitblock::any(simd_and(EndTagEnds, lex.WS)) || carryQ.CarryTest(11, 1))) {
624          carryQ.cq[11] = carryout2carry(pablo_blk_ScanThru(EndTagEnds, lex.WS, carryQ.get_carry_in(11), EndTagEnds));
625        }
626        else {
627          carryQ.CarryDequeueEnqueue(11, 1);
628        }
629        ParseError = simd_or(ParseError, simd_andc(EndTagEnds, lex.RAngle));
630        if (bitblock::any(ParseError)) {
631          assert_0_error("Tag parsing error found", ParseError);
632        }
633        carryQ.cq[12] = carryout2carry(pablo_blk_SpanUpTo(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carryQ.get_carry_in(12), tag_Callouts.AttVal_spans));
634        tag_Callouts.Content_starts = STagEnds;
635        tag_Callouts.Tag_closing = simd_or(tag_Callouts.EmptyTag_marks, tag_Callouts.EndTag_marks);
636        carryQ.CarryQ_Adjust(13);
637  }
638  IDISA_INLINE void clear() { 
639 }
640  void do_final_block(Lex & lex, Marker & marker, Tag_Callouts & tag_Callouts, BitBlock EOF_mask) {
641                BitBlock EqExpected, AttListEnd, DQuoteDelim, SQuoteDelim, AttListDelim;
642                BitBlock ParseError, AfterWS, AttNameStart, AttNameFollow, AttValPos;
643                BitBlock DQuoteAttVal, SQuoteAttVal, DQuoteAttEnd, SQuoteAttEnd, AttValEnd;
644                BitBlock AttValFollow, STagEnds, EndTagEnds;
645
646
647
648
649        EqExpected = simd<1>::constant<0>();
650        AttListEnd = simd<1>::constant<0>();
651        DQuoteDelim = simd_or(lex.DQuote, lex.LAngle);
652        SQuoteDelim = simd_or(lex.SQuote, lex.LAngle);
653        AttListDelim = simd_or(lex.Slash, lex.RAngle);
654        tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope, lex.Slash);
655        tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope, lex.Slash);
656        carryQ.cq[0] = carryout2carry(pablo_blk_ScanThru(tag_Callouts.ElemName_starts, lex.NameScan, carryQ.get_carry_in(0), tag_Callouts.ElemName_ends));
657        ParseError = simd_and(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
658        tag_Callouts.AttName_starts = simd<1>::constant<0>();
659        tag_Callouts.AttName_ends = simd<1>::constant<0>();
660        tag_Callouts.AttVal_starts = simd<1>::constant<0>();
661        tag_Callouts.AttVal_ends = simd<1>::constant<0>();
662        if ((bitblock::any(simd_and(tag_Callouts.ElemName_ends, lex.WS)) || carryQ.CarryTest(1, 8))) {
663          carryQ.cq[1] = carryout2carry(pablo_blk_ScanThru(tag_Callouts.ElemName_ends, lex.WS, carryQ.get_carry_in(1), AfterWS));
664          AttListEnd = simd_and(AfterWS, AttListDelim);
665          AttNameStart = simd_andc(AfterWS, AttListDelim);
666          if ((bitblock::any(simd_and(AttNameStart, EOF_mask)) || carryQ.CarryTest(2, 7))) {
667            ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
668            tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
669            carryQ.cq[2] = carryout2carry(pablo_blk_ScanThru(AttNameStart, lex.NameScan, carryQ.get_carry_in(2), AttNameFollow));
670            tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
671            if ((bitblock::any(simd_and(AttNameFollow, lex.WS)) || carryQ.CarryTest(3, 1))) {
672              carryQ.cq[3] = carryout2carry(pablo_blk_ScanThru(AttNameFollow, lex.WS, carryQ.get_carry_in(3), EqExpected));
673            }
674            else {
675              EqExpected = AttNameFollow;
676              carryQ.CarryDequeueEnqueue(3, 1);
677            }
678            ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
679            carryQ.cq[4] = carryout2carry(pablo_blk_AdvanceThenScanThru(EqExpected, lex.WS, carryQ.get_carry_in(4), AttValPos));
680            tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
681            DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
682            SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
683            carryQ.cq[5] = carryout2carry(pablo_blk_AdvanceThenScanThru(DQuoteAttVal, simd_andc(EOF_mask, DQuoteDelim), carryQ.get_carry_in(5), DQuoteAttEnd));
684            carryQ.cq[6] = carryout2carry(pablo_blk_AdvanceThenScanThru(SQuoteAttVal, simd_andc(EOF_mask, SQuoteDelim), carryQ.get_carry_in(6), SQuoteAttEnd));
685            AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
686            ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
687            carryQ.cq[7] = carryout2carry(pablo_blk_Advance(AttValEnd, carryQ.get_carry_in(7), AttValFollow));
688            tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
689            if ((bitblock::any(simd_and(AttValFollow, lex.WS)) || carryQ.CarryTest(8, 1))) {
690              carryQ.cq[8] = carryout2carry(pablo_blk_ScanThru(AttValFollow, lex.WS, carryQ.get_carry_in(8), AfterWS));
691              AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
692              AttNameStart = simd_andc(AfterWS, AttListDelim);
693            }
694            else {
695              AttListEnd = simd_or(AttListEnd, simd_and(AttValFollow, AttListDelim));
696              AttNameStart = simd_andc(AttValFollow, AttListDelim);
697              carryQ.CarryDequeueEnqueue(8, 1);
698            }
699            ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
700            while (bitblock::any(simd_and(AttNameStart, EOF_mask))) {
701              LocalCarryDeclare(subcarryQ, 7);
702              ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
703              tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
704              subcarryQ.cq[0] = carryout2carry(pablo_blk_ScanThru(AttNameStart, lex.NameScan, carry_value_0, AttNameFollow));
705              tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
706              if (bitblock::any(simd_and(AttNameFollow, lex.WS))) {
707                subcarryQ.cq[1] = carryout2carry(pablo_blk_ScanThru(AttNameFollow, lex.WS, carry_value_0, EqExpected));
708              }
709              else {
710                EqExpected = AttNameFollow;
711                subcarryQ.CarryDequeueEnqueue(3, 1);
712              }
713              ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
714              subcarryQ.cq[2] = carryout2carry(pablo_blk_AdvanceThenScanThru(EqExpected, lex.WS, carry_value_0, AttValPos));
715              tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
716              DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
717              SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
718              subcarryQ.cq[3] = carryout2carry(pablo_blk_AdvanceThenScanThru(DQuoteAttVal, simd_andc(EOF_mask, DQuoteDelim), carry_value_0, DQuoteAttEnd));
719              subcarryQ.cq[4] = carryout2carry(pablo_blk_AdvanceThenScanThru(SQuoteAttVal, simd_andc(EOF_mask, SQuoteDelim), carry_value_0, SQuoteAttEnd));
720              AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
721              ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
722              subcarryQ.cq[5] = carryout2carry(pablo_blk_Advance(AttValEnd, carry_value_0, AttValFollow));
723              tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
724              if (bitblock::any(simd_and(AttValFollow, lex.WS))) {
725                subcarryQ.cq[6] = carryout2carry(pablo_blk_ScanThru(AttValFollow, lex.WS, carry_value_0, AfterWS));
726                AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
727                AttNameStart = simd_andc(AfterWS, AttListDelim);
728              }
729              else {
730                AttListEnd = simd_or(AttListEnd, simd_and(AttValFollow, AttListDelim));
731                AttNameStart = simd_andc(AttValFollow, AttListDelim);
732                subcarryQ.CarryDequeueEnqueue(8, 1);
733              }
734              ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
735              carryQ.CarryCombine(subcarryQ.cq, 2, 7);
736            }
737          }
738          else {
739            carryQ.CarryDequeueEnqueue(2, 7);
740          }
741        }
742        else {
743          AttListEnd = simd_and(tag_Callouts.ElemName_ends, AttListDelim);
744          ParseError = simd_or(ParseError, simd_andc(tag_Callouts.ElemName_ends, AttListDelim));
745          carryQ.CarryDequeueEnqueue(1, 8);
746        }
747        STagEnds = simd_and(AttListEnd, lex.RAngle);
748        carryQ.cq[9] = carryout2carry(pablo_blk_Advance(simd_and(AttListEnd, lex.Slash), carryQ.get_carry_in(9), tag_Callouts.EmptyTag_marks));
749        ParseError = simd_or(ParseError, simd_andc(tag_Callouts.EmptyTag_marks, lex.RAngle));
750        carryQ.cq[10] = carryout2carry(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks, lex.NameScan, carryQ.get_carry_in(10), EndTagEnds));
751        if ((bitblock::any(simd_and(EndTagEnds, lex.WS)) || carryQ.CarryTest(11, 1))) {
752          carryQ.cq[11] = carryout2carry(pablo_blk_ScanThru(EndTagEnds, lex.WS, carryQ.get_carry_in(11), EndTagEnds));
753        }
754        else {
755          carryQ.CarryDequeueEnqueue(11, 1);
756        }
757        ParseError = simd_or(ParseError, simd_andc(EndTagEnds, lex.RAngle));
758        if (bitblock::any(ParseError)) {
759          assert_0_error("Tag parsing error found", ParseError);
760        }
761        carryQ.cq[12] = carryout2carry(pablo_blk_SpanUpTo(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carryQ.get_carry_in(12), tag_Callouts.AttVal_spans));
762        tag_Callouts.Content_starts = STagEnds;
763        tag_Callouts.Tag_closing = simd_or(tag_Callouts.EmptyTag_marks, tag_Callouts.EndTag_marks);
764  }
765  CarryArray<13, 0> carryQ;
766  };
767
768  struct Classify_bytes_Validate_utf8 {
769  Classify_bytes_Validate_utf8() { 
770 }
771  IDISA_INLINE void do_block(Basis_bits & basis_bits, Lex & lex, U8 & u8) {
772                BitBlock temp1, temp2, temp3, temp4, temp5, temp6, temp7, temp8, temp9, temp10;
773                BitBlock temp11, temp12, temp13, temp14, temp15, temp16, temp17, temp18;
774                BitBlock temp19, temp20, temp21, temp22, temp23, temp24, temp25, temp26;
775                BitBlock temp27, temp28, temp29, temp30, temp31, temp32, temp33, temp34;
776                BitBlock temp35, temp36, temp37, temp38, temp39, temp40, temp41, temp42;
777                BitBlock temp43, temp44, temp45, temp46, temp47, temp48, x00_x1F, temp49;
778                BitBlock temp50, temp51, temp52, temp53, temp54, temp55, temp56, temp57;
779                BitBlock temp58, temp59, temp60, temp61, temp62, temp63, temp64, temp65;
780                BitBlock lex_error, u8_error, u8_FFFE_FFFF, u8anyscope, temp66, temp67, temp68;
781                BitBlock temp69, temp70, temp71, xE0, xED, xF0, temp72, xF4, xEF, temp73;
782                BitBlock u8lastscope, u8error1, u8error2, u8error3, u8error4, EF_BF_pending;
783                BitBlock u8mismatch;
784
785
786
787
788        temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
789        temp2 = simd_andc(basis_bits.bit_2, basis_bits.bit_3);
790        temp3 = simd_andc(temp2, temp1);
791        temp4 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
792        temp5 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
793        temp6 = simd_and(temp4, temp5);
794        lex.RefStart = simd_and(temp3, temp6);
795        temp7 = simd_and(basis_bits.bit_2, basis_bits.bit_3);
796        temp8 = simd_andc(temp7, temp1);
797        temp9 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
798        temp10 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
799        temp11 = simd_and(temp9, temp10);
800        lex.Semicolon = simd_and(temp8, temp11);
801        temp12 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
802        temp13 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
803        temp14 = simd_andc(temp12, temp13);
804        lex.LAngle = simd_and(temp8, temp14);
805        temp15 = simd_and(temp12, temp5);
806        lex.RAngle = simd_and(temp8, temp15);
807        temp16 = simd_andc(basis_bits.bit_1, basis_bits.bit_0);
808        temp17 = simd_andc(basis_bits.bit_3, basis_bits.bit_2);
809        temp18 = simd_and(temp16, temp17);
810        lex.LBracket = simd_and(temp18, temp11);
811        temp19 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
812        temp20 = simd_and(temp12, temp19);
813        lex.RBracket = simd_and(temp18, temp20);
814        temp21 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
815        temp22 = simd_andc(temp19, temp21);
816        lex.Exclam = simd_and(temp3, temp22);
817        temp23 = simd_and(temp12, temp10);
818        lex.QMark = simd_and(temp8, temp23);
819        lex.Hyphen = simd_and(temp3, temp20);
820        lex.Equals = simd_and(temp8, temp20);
821        temp24 = simd_and(temp4, temp10);
822        lex.SQuote = simd_and(temp3, temp24);
823        temp25 = simd_andc(temp5, temp21);
824        lex.DQuote = simd_and(temp3, temp25);
825        lex.Slash = simd_and(temp3, temp23);
826        temp26 = simd_andc(temp10, temp21);
827        lex.Hash = simd_and(temp3, temp26);
828        temp27 = simd_and(temp16, temp7);
829        temp28 = simd_andc(temp9, temp13);
830        lex.x = simd_and(temp27, temp28);
831        temp29 = simd_and(temp9, temp5);
832        lex.Colon = simd_and(temp8, temp29);
833        temp30 = simd_and(temp18, temp23);
834        temp31 = simd_or(temp30, lex.Colon);
835        temp32 = simd_andc(temp16, basis_bits.bit_2);
836        temp33 = simd_or(basis_bits.bit_5, temp10);
837        temp34 = simd_and(basis_bits.bit_4, temp33);
838        temp35 = simd_not(temp34);
839        temp36 = simd_or(temp21, temp13);
840        temp37 = simd_or(simd_and(basis_bits.bit_3, temp35), simd_andc(temp36, basis_bits.bit_3));
841        temp38 = simd_and(temp32, temp37);
842        temp39 = simd_or(temp31, temp38);
843        temp40 = simd_and(temp16, basis_bits.bit_2);
844        temp41 = simd_and(temp40, temp37);
845        lex.ASCII_name_start = simd_or(temp39, temp41);
846        temp42 = simd_or(temp30, lex.Hyphen);
847        temp43 = simd_and(temp3, temp15);
848        temp44 = simd_or(temp42, temp43);
849        temp45 = simd_andc(temp8, temp34);
850        temp46 = simd_or(temp44, temp45);
851        temp47 = simd_or(temp46, temp38);
852        lex.ASCII_name_char = simd_or(temp47, temp41);
853        lex.NameScan = simd_or(lex.ASCII_name_char, basis_bits.bit_0);
854        temp48 = simd_or(temp1, basis_bits.bit_2);
855        x00_x1F = simd_not(temp48);
856        temp49 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
857        temp50 = simd_or(temp1, temp49);
858        lex.CR = simd_andc(temp20, temp50);
859        lex.LF = simd_andc(temp29, temp50);
860        temp51 = simd_and(temp9, temp19);
861        lex.HT = simd_andc(temp51, temp50);
862        lex.SP = simd_andc(temp3, temp36);
863        temp52 = simd_or(temp20, temp29);
864        temp53 = simd_or(temp52, temp51);
865        temp54 = simd_andc(temp53, temp50);
866        lex.WS = simd_or(temp54, lex.SP);
867        temp55 = simd_or(basis_bits.bit_5, basis_bits.bit_6);
868        temp56 = simd_and(basis_bits.bit_4, temp55);
869        lex.Digit = simd_andc(temp8, temp56);
870        temp57 = simd_andc(temp16, temp49);
871        temp58 = simd_andc(temp57, basis_bits.bit_4);
872        temp59 = simd_not(temp10);
873        temp60 = simd_or(simd_and(basis_bits.bit_5, temp59), simd_andc(temp13, basis_bits.bit_5));
874        temp61 = simd_and(temp58, temp60);
875        temp62 = simd_or(lex.Digit, temp61);
876        temp63 = simd_and(temp16, temp2);
877        temp64 = simd_andc(temp63, basis_bits.bit_4);
878        temp65 = simd_and(temp64, temp60);
879        lex.Hex = simd_or(temp62, temp65);
880        lex_error = simd_andc(x00_x1F, lex.WS);
881        if (bitblock::any(simd_and(lex_error, EOF_mask))) {
882          error_tracker.NoteError("Error: illegal character", lex_error);
883        }
884        u8.unibyte = simd_not(basis_bits.bit_0);
885        u8.suffix = simd<1>::constant<0>();
886        u8_error = simd<1>::constant<0>();
887        u8_FFFE_FFFF = simd<1>::constant<0>();
888        u8anyscope = simd<1>::constant<0>();
889        if ((bitblock::any(basis_bits.bit_0) || carryQ.CarryTest(0, 12))) {
890          u8.prefix = simd_and(basis_bits.bit_0, basis_bits.bit_1);
891          u8.prefix2 = simd_andc(u8.prefix, basis_bits.bit_2);
892          u8.prefix3 = simd_and(u8.prefix, temp2);
893          u8.prefix4 = simd_and(u8.prefix, temp7);
894          u8.suffix = simd_andc(basis_bits.bit_0, basis_bits.bit_1);
895          temp66 = simd_andc(u8.prefix, temp49);
896          temp67 = simd_or(temp21, basis_bits.bit_6);
897          temp68 = simd_andc(temp66, temp67);
898          temp69 = simd_and(basis_bits.bit_5, temp13);
899          temp70 = simd_or(basis_bits.bit_4, temp69);
900          temp71 = simd_and(u8.prefix4, temp70);
901          u8.badprefix = simd_or(temp68, temp71);
902          u8_error = u8.badprefix;
903          carryQ.cq[0] = carryout2carry(pablo_blk_Advance(u8.prefix2, carryQ.get_carry_in(0), u8.scope22));
904          u8anyscope = u8.scope22;
905          if ((bitblock::any(simd_or(u8.prefix3, u8.prefix4)) || carryQ.CarryTest(1, 11))) {
906            xE0 = simd_andc(u8.prefix3, temp36);
907            xED = simd_and(u8.prefix3, temp20);
908            xF0 = simd_andc(u8.prefix4, temp36);
909            temp72 = simd_andc(temp4, temp13);
910            xF4 = simd_and(u8.prefix4, temp72);
911            u8.xA0_xBF = simd_and(u8.suffix, basis_bits.bit_2);
912            u8.x80_x9F = simd_andc(u8.suffix, basis_bits.bit_2);
913            u8.x90_xBF = simd_and(u8.suffix, temp49);
914            u8.x80_x8F = simd_andc(u8.suffix, temp49);
915            xEF = simd_and(u8.prefix3, temp23);
916            temp73 = simd_and(u8.suffix, temp7);
917            u8.xBF = simd_and(temp73, temp23);
918            u8.xBE = simd_and(temp73, temp15);
919            carryQ.cq[1] = carryout2carry(pablo_blk_Advance(xE0, carryQ.get_carry_in(1), u8.xE0_scope));
920            carryQ.cq[2] = carryout2carry(pablo_blk_Advance(xED, carryQ.get_carry_in(2), u8.xED_scope));
921            carryQ.cq[3] = carryout2carry(pablo_blk_Advance(xF0, carryQ.get_carry_in(3), u8.xF0_scope));
922            carryQ.cq[4] = carryout2carry(pablo_blk_Advance(xF4, carryQ.get_carry_in(4), u8.xF4_scope));
923            carryQ.cq[5] = carryout2carry(pablo_blk_Advance(xEF, carryQ.get_carry_in(5), u8.xEF_scope));
924            carryQ.cq[6] = carryout2carry(pablo_blk_Advance(u8.prefix3, carryQ.get_carry_in(6), u8.scope32));
925            carryQ.cq[7] = carryout2carry(pablo_blk_Advance(u8.scope32, carryQ.get_carry_in(7), u8.scope33));
926            carryQ.cq[8] = carryout2carry(pablo_blk_Advance(u8.prefix4, carryQ.get_carry_in(8), u8.scope42));
927            carryQ.cq[9] = carryout2carry(pablo_blk_Advance(u8.scope42, carryQ.get_carry_in(9), u8.scope43));
928            carryQ.cq[10] = carryout2carry(pablo_blk_Advance(u8.scope43, carryQ.get_carry_in(10), u8.scope44));
929            u8lastscope = simd_or(simd_or(u8.scope22, u8.scope33), u8.scope44);
930            u8anyscope = simd_or(simd_or(simd_or(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
931            u8error1 = simd_and(u8.xE0_scope, u8.x80_x9F);
932            u8error2 = simd_and(u8.xED_scope, u8.xA0_xBF);
933            u8error3 = simd_and(u8.xF0_scope, u8.x80_x8F);
934            u8error4 = simd_and(u8.xF4_scope, u8.x90_xBF);
935            u8_error = simd_or(u8_error, simd_or(simd_or(simd_or(u8error1, u8error2), u8error3), u8error4));
936            carryQ.cq[11] = carryout2carry(pablo_blk_Advance(simd_and(u8.xEF_scope, u8.xBF), carryQ.get_carry_in(11), EF_BF_pending));
937            u8_FFFE_FFFF = simd_and(EF_BF_pending, simd_or(u8.xBE, u8.xBF));
938          }
939          else {
940            carryQ.CarryDequeueEnqueue(1, 11);
941          }
942          u8mismatch = simd_xor(u8anyscope, u8.suffix);
943          u8_error = simd_or(u8_error, simd_or(u8mismatch, u8_FFFE_FFFF));
944          if (bitblock::any(u8_error)) {
945            error_tracker.NoteError("UTF-8 error found", u8_error);
946          }
947        }
948        else {
949          carryQ.CarryDequeueEnqueue(0, 12);
950        }
951        temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
952        temp2 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
953        temp3 = simd_or(temp1, temp2);
954        temp4 = simd_or(basis_bits.bit_5, basis_bits.bit_6);
955        temp5 = simd_and(basis_bits.bit_4, temp4);
956        temp6 = simd_or(temp3, temp5);
957        temp7 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
958        temp8 = simd_or(basis_bits.bit_5, temp7);
959        temp9 = simd_and(basis_bits.bit_4, temp8);
960        temp10 = simd_or(temp2, temp9);
961        temp11 = simd_or(basis_bits.bit_1, temp10);
962        temp12 = simd_or(basis_bits.bit_0, temp11);
963        temp13 = simd_andc(temp6, temp12);
964        lex.Caret = simd_not(temp13);
965        temp14 = simd_andc(basis_bits.bit_2, basis_bits.bit_3);
966        temp15 = simd_andc(temp14, temp1);
967        temp16 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
968        temp17 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
969        temp18 = simd_and(temp16, temp17);
970        lex.Dot = simd_and(temp15, temp18);
971        temp19 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
972        temp20 = simd_andc(temp7, temp19);
973        lex.content_end = simd_and(temp15, temp20);
974        temp21 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
975        temp22 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
976        temp23 = simd_and(temp21, temp22);
977        temp24 = simd_andc(basis_bits.bit_1, basis_bits.bit_0);
978        temp25 = simd_andc(temp2, temp14);
979        temp26 = simd_andc(temp24, temp25);
980        lex.E_and_e = simd_and(temp23, temp26);
981        temp27 = simd_and(basis_bits.bit_2, basis_bits.bit_3);
982        temp28 = simd_andc(temp27, temp1);
983        lex.Digit = simd_andc(temp28, temp5);
984        temp29 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
985        temp30 = simd_and(temp29, temp7);
986        temp31 = simd_and(temp16, temp22);
987        temp32 = simd_or(temp30, temp31);
988        lex.P_H_sign = simd_and(temp15, temp32);
989        carryQ.CarryQ_Adjust(12);
990  }
991  IDISA_INLINE void clear() { 
992 }
993  void do_final_block(Basis_bits & basis_bits, Lex & lex, U8 & u8, BitBlock EOF_mask) {
994                BitBlock temp1, temp2, temp3, temp4, temp5, temp6, temp7, temp8, temp9, temp10;
995                BitBlock temp11, temp12, temp13, temp14, temp15, temp16, temp17, temp18;
996                BitBlock temp19, temp20, temp21, temp22, temp23, temp24, temp25, temp26;
997                BitBlock temp27, temp28, temp29, temp30, temp31, temp32, temp33, temp34;
998                BitBlock temp35, temp36, temp37, temp38, temp39, temp40, temp41, temp42;
999                BitBlock temp43, temp44, temp45, temp46, temp47, temp48, x00_x1F, temp49;
1000                BitBlock temp50, temp51, temp52, temp53, temp54, temp55, temp56, temp57;
1001                BitBlock temp58, temp59, temp60, temp61, temp62, temp63, temp64, temp65;
1002                BitBlock lex_error, u8_error, u8_FFFE_FFFF, u8anyscope, temp66, temp67, temp68;
1003                BitBlock temp69, temp70, temp71, xE0, xED, xF0, temp72, xF4, xEF, temp73;
1004                BitBlock u8lastscope, u8error1, u8error2, u8error3, u8error4, EF_BF_pending;
1005                BitBlock u8mismatch;
1006
1007
1008
1009
1010        temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
1011        temp2 = simd_andc(basis_bits.bit_2, basis_bits.bit_3);
1012        temp3 = simd_andc(temp2, temp1);
1013        temp4 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
1014        temp5 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
1015        temp6 = simd_and(temp4, temp5);
1016        lex.RefStart = simd_and(temp3, temp6);
1017        temp7 = simd_and(basis_bits.bit_2, basis_bits.bit_3);
1018        temp8 = simd_andc(temp7, temp1);
1019        temp9 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
1020        temp10 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
1021        temp11 = simd_and(temp9, temp10);
1022        lex.Semicolon = simd_and(temp8, temp11);
1023        temp12 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
1024        temp13 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
1025        temp14 = simd_andc(temp12, temp13);
1026        lex.LAngle = simd_and(temp8, temp14);
1027        temp15 = simd_and(temp12, temp5);
1028        lex.RAngle = simd_and(temp8, temp15);
1029        temp16 = simd_andc(basis_bits.bit_1, basis_bits.bit_0);
1030        temp17 = simd_andc(basis_bits.bit_3, basis_bits.bit_2);
1031        temp18 = simd_and(temp16, temp17);
1032        lex.LBracket = simd_and(temp18, temp11);
1033        temp19 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
1034        temp20 = simd_and(temp12, temp19);
1035        lex.RBracket = simd_and(temp18, temp20);
1036        temp21 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
1037        temp22 = simd_andc(temp19, temp21);
1038        lex.Exclam = simd_and(temp3, temp22);
1039        temp23 = simd_and(temp12, temp10);
1040        lex.QMark = simd_and(temp8, temp23);
1041        lex.Hyphen = simd_and(temp3, temp20);
1042        lex.Equals = simd_and(temp8, temp20);
1043        temp24 = simd_and(temp4, temp10);
1044        lex.SQuote = simd_and(temp3, temp24);
1045        temp25 = simd_andc(temp5, temp21);
1046        lex.DQuote = simd_and(temp3, temp25);
1047        lex.Slash = simd_and(temp3, temp23);
1048        temp26 = simd_andc(temp10, temp21);
1049        lex.Hash = simd_and(temp3, temp26);
1050        temp27 = simd_and(temp16, temp7);
1051        temp28 = simd_andc(temp9, temp13);
1052        lex.x = simd_and(temp27, temp28);
1053        temp29 = simd_and(temp9, temp5);
1054        lex.Colon = simd_and(temp8, temp29);
1055        temp30 = simd_and(temp18, temp23);
1056        temp31 = simd_or(temp30, lex.Colon);
1057        temp32 = simd_andc(temp16, basis_bits.bit_2);
1058        temp33 = simd_or(basis_bits.bit_5, temp10);
1059        temp34 = simd_and(basis_bits.bit_4, temp33);
1060        temp35 = simd_not(temp34);
1061        temp36 = simd_or(temp21, temp13);
1062        temp37 = simd_or(simd_and(basis_bits.bit_3, temp35), simd_andc(temp36, basis_bits.bit_3));
1063        temp38 = simd_and(temp32, temp37);
1064        temp39 = simd_or(temp31, temp38);
1065        temp40 = simd_and(temp16, basis_bits.bit_2);
1066        temp41 = simd_and(temp40, temp37);
1067        lex.ASCII_name_start = simd_or(temp39, temp41);
1068        temp42 = simd_or(temp30, lex.Hyphen);
1069        temp43 = simd_and(temp3, temp15);
1070        temp44 = simd_or(temp42, temp43);
1071        temp45 = simd_andc(temp8, temp34);
1072        temp46 = simd_or(temp44, temp45);
1073        temp47 = simd_or(temp46, temp38);
1074        lex.ASCII_name_char = simd_or(temp47, temp41);
1075        lex.NameScan = simd_or(lex.ASCII_name_char, basis_bits.bit_0);
1076        temp48 = simd_or(temp1, basis_bits.bit_2);
1077        x00_x1F = simd_not(temp48);
1078        temp49 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
1079        temp50 = simd_or(temp1, temp49);
1080        lex.CR = simd_andc(temp20, temp50);
1081        lex.LF = simd_andc(temp29, temp50);
1082        temp51 = simd_and(temp9, temp19);
1083        lex.HT = simd_andc(temp51, temp50);
1084        lex.SP = simd_andc(temp3, temp36);
1085        temp52 = simd_or(temp20, temp29);
1086        temp53 = simd_or(temp52, temp51);
1087        temp54 = simd_andc(temp53, temp50);
1088        lex.WS = simd_or(temp54, lex.SP);
1089        temp55 = simd_or(basis_bits.bit_5, basis_bits.bit_6);
1090        temp56 = simd_and(basis_bits.bit_4, temp55);
1091        lex.Digit = simd_andc(temp8, temp56);
1092        temp57 = simd_andc(temp16, temp49);
1093        temp58 = simd_andc(temp57, basis_bits.bit_4);
1094        temp59 = simd_not(temp10);
1095        temp60 = simd_or(simd_and(basis_bits.bit_5, temp59), simd_andc(temp13, basis_bits.bit_5));
1096        temp61 = simd_and(temp58, temp60);
1097        temp62 = simd_or(lex.Digit, temp61);
1098        temp63 = simd_and(temp16, temp2);
1099        temp64 = simd_andc(temp63, basis_bits.bit_4);
1100        temp65 = simd_and(temp64, temp60);
1101        lex.Hex = simd_or(temp62, temp65);
1102        lex_error = simd_andc(x00_x1F, lex.WS);
1103        if (bitblock::any(simd_and(lex_error, EOF_mask))) {
1104          error_tracker.NoteError("Error: illegal character", lex_error);
1105        }
1106        u8.unibyte = simd_not(basis_bits.bit_0);
1107        u8.suffix = simd<1>::constant<0>();
1108        u8_error = simd<1>::constant<0>();
1109        u8_FFFE_FFFF = simd<1>::constant<0>();
1110        u8anyscope = simd<1>::constant<0>();
1111        if ((bitblock::any(basis_bits.bit_0) || carryQ.CarryTest(0, 12))) {
1112          u8.prefix = simd_and(basis_bits.bit_0, basis_bits.bit_1);
1113          u8.prefix2 = simd_andc(u8.prefix, basis_bits.bit_2);
1114          u8.prefix3 = simd_and(u8.prefix, temp2);
1115          u8.prefix4 = simd_and(u8.prefix, temp7);
1116          u8.suffix = simd_andc(basis_bits.bit_0, basis_bits.bit_1);
1117          temp66 = simd_andc(u8.prefix, temp49);
1118          temp67 = simd_or(temp21, basis_bits.bit_6);
1119          temp68 = simd_andc(temp66, temp67);
1120          temp69 = simd_and(basis_bits.bit_5, temp13);
1121          temp70 = simd_or(basis_bits.bit_4, temp69);
1122          temp71 = simd_and(u8.prefix4, temp70);
1123          u8.badprefix = simd_or(temp68, temp71);
1124          u8_error = u8.badprefix;
1125          carryQ.cq[0] = carryout2carry(pablo_blk_Advance(u8.prefix2, carryQ.get_carry_in(0), u8.scope22));
1126          u8anyscope = u8.scope22;
1127          if ((bitblock::any(simd_or(u8.prefix3, u8.prefix4)) || carryQ.CarryTest(1, 11))) {
1128            xE0 = simd_andc(u8.prefix3, temp36);
1129            xED = simd_and(u8.prefix3, temp20);
1130            xF0 = simd_andc(u8.prefix4, temp36);
1131            temp72 = simd_andc(temp4, temp13);
1132            xF4 = simd_and(u8.prefix4, temp72);
1133            u8.xA0_xBF = simd_and(u8.suffix, basis_bits.bit_2);
1134            u8.x80_x9F = simd_andc(u8.suffix, basis_bits.bit_2);
1135            u8.x90_xBF = simd_and(u8.suffix, temp49);
1136            u8.x80_x8F = simd_andc(u8.suffix, temp49);
1137            xEF = simd_and(u8.prefix3, temp23);
1138            temp73 = simd_and(u8.suffix, temp7);
1139            u8.xBF = simd_and(temp73, temp23);
1140            u8.xBE = simd_and(temp73, temp15);
1141            carryQ.cq[1] = carryout2carry(pablo_blk_Advance(xE0, carryQ.get_carry_in(1), u8.xE0_scope));
1142            carryQ.cq[2] = carryout2carry(pablo_blk_Advance(xED, carryQ.get_carry_in(2), u8.xED_scope));
1143            carryQ.cq[3] = carryout2carry(pablo_blk_Advance(xF0, carryQ.get_carry_in(3), u8.xF0_scope));
1144            carryQ.cq[4] = carryout2carry(pablo_blk_Advance(xF4, carryQ.get_carry_in(4), u8.xF4_scope));
1145            carryQ.cq[5] = carryout2carry(pablo_blk_Advance(xEF, carryQ.get_carry_in(5), u8.xEF_scope));
1146            carryQ.cq[6] = carryout2carry(pablo_blk_Advance(u8.prefix3, carryQ.get_carry_in(6), u8.scope32));
1147            carryQ.cq[7] = carryout2carry(pablo_blk_Advance(u8.scope32, carryQ.get_carry_in(7), u8.scope33));
1148            carryQ.cq[8] = carryout2carry(pablo_blk_Advance(u8.prefix4, carryQ.get_carry_in(8), u8.scope42));
1149            carryQ.cq[9] = carryout2carry(pablo_blk_Advance(u8.scope42, carryQ.get_carry_in(9), u8.scope43));
1150            carryQ.cq[10] = carryout2carry(pablo_blk_Advance(u8.scope43, carryQ.get_carry_in(10), u8.scope44));
1151            u8lastscope = simd_or(simd_or(u8.scope22, u8.scope33), u8.scope44);
1152            u8anyscope = simd_or(simd_or(simd_or(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
1153            u8error1 = simd_and(u8.xE0_scope, u8.x80_x9F);
1154            u8error2 = simd_and(u8.xED_scope, u8.xA0_xBF);
1155            u8error3 = simd_and(u8.xF0_scope, u8.x80_x8F);
1156            u8error4 = simd_and(u8.xF4_scope, u8.x90_xBF);
1157            u8_error = simd_or(u8_error, simd_or(simd_or(simd_or(u8error1, u8error2), u8error3), u8error4));
1158            carryQ.cq[11] = carryout2carry(pablo_blk_Advance(simd_and(u8.xEF_scope, u8.xBF), carryQ.get_carry_in(11), EF_BF_pending));
1159            u8_FFFE_FFFF = simd_and(EF_BF_pending, simd_or(u8.xBE, u8.xBF));
1160          }
1161          else {
1162            carryQ.CarryDequeueEnqueue(1, 11);
1163          }
1164          u8mismatch = simd_xor(u8anyscope, u8.suffix);
1165          u8_error = simd_or(u8_error, simd_or(u8mismatch, u8_FFFE_FFFF));
1166          if (bitblock::any(u8_error)) {
1167            error_tracker.NoteError("UTF-8 error found", u8_error);
1168          }
1169        }
1170        else {
1171          carryQ.CarryDequeueEnqueue(0, 12);
1172        }
1173        temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
1174        temp2 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
1175        temp3 = simd_or(temp1, temp2);
1176        temp4 = simd_or(basis_bits.bit_5, basis_bits.bit_6);
1177        temp5 = simd_and(basis_bits.bit_4, temp4);
1178        temp6 = simd_or(temp3, temp5);
1179        temp7 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
1180        temp8 = simd_or(basis_bits.bit_5, temp7);
1181        temp9 = simd_and(basis_bits.bit_4, temp8);
1182        temp10 = simd_or(temp2, temp9);
1183        temp11 = simd_or(basis_bits.bit_1, temp10);
1184        temp12 = simd_or(basis_bits.bit_0, temp11);
1185        temp13 = simd_andc(temp6, temp12);
1186        lex.Caret = simd_not(temp13);
1187        temp14 = simd_andc(basis_bits.bit_2, basis_bits.bit_3);
1188        temp15 = simd_andc(temp14, temp1);
1189        temp16 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
1190        temp17 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
1191        temp18 = simd_and(temp16, temp17);
1192        lex.Dot = simd_and(temp15, temp18);
1193        temp19 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
1194        temp20 = simd_andc(temp7, temp19);
1195        lex.content_end = simd_and(temp15, temp20);
1196        temp21 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
1197        temp22 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
1198        temp23 = simd_and(temp21, temp22);
1199        temp24 = simd_andc(basis_bits.bit_1, basis_bits.bit_0);
1200        temp25 = simd_andc(temp2, temp14);
1201        temp26 = simd_andc(temp24, temp25);
1202        lex.E_and_e = simd_and(temp23, temp26);
1203        temp27 = simd_and(basis_bits.bit_2, basis_bits.bit_3);
1204        temp28 = simd_andc(temp27, temp1);
1205        lex.Digit = simd_andc(temp28, temp5);
1206        temp29 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
1207        temp30 = simd_and(temp29, temp7);
1208        temp31 = simd_and(temp16, temp22);
1209        temp32 = simd_or(temp30, temp31);
1210        lex.P_H_sign = simd_and(temp15, temp32);
1211  }
1212  CarryArray<12, 0> carryQ;
1213  };
1214
1215  struct Parse_CtCDPI {
1216  Parse_CtCDPI() { 
1217carryQ.cq[4] = carryQ.carry_flip(carryQ.cq[4]);
1218 }
1219  IDISA_INLINE void do_block(Lex & lex, Marker & marker, CtCDPI_Callouts & ctCDPI_Callouts, Check_streams & check_streams) {
1220                BitBlock CtCDPI_starts, CtCDPI_ends, ctCDPI_mask, v, w, v1, w1, LAngle_scope;
1221                BitBlock PI_opener, CtCD_opener, CtCDPI_opener, CD_closer, DoubleHyphen;
1222                BitBlock DoubleRBracket, PI_closer, CtCDPI_Cursor, PI_Cursor, CD_Ct_Cursor;
1223                BitBlock CD_Cursor, Ct_Cursor, PI_name_end, PI_error, PI_noWS, Ct_error;
1224
1225                BitBlock tempvar0, tempvar1, tempvar2, tempvar3, tempvar4, tempvar5;
1226
1227
1228        ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
1229        ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
1230        ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
1231        ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
1232        ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
1233        ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
1234        ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
1235        ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
1236        CtCDPI_starts = simd<1>::constant<0>();
1237        CtCDPI_ends = simd<1>::constant<0>();
1238        ctCDPI_mask = simd<1>::constant<0>();
1239        v = simd_or(lex.LAngle, lex.Hyphen);
1240        w = simd_or(lex.Hyphen, lex.QMark);
1241        carryQ.cq[0] = carryout2carry(pablo_blk_Advance(v, carryQ.get_carry_in(0), v1));
1242        carryQ.cq[1] = carryout2carry(pablo_blk_Advance(w, carryQ.get_carry_in(1), w1));
1243        LAngle_scope = simd_andc(v1, w1);
1244        PI_opener = simd_and(LAngle_scope, lex.QMark);
1245        CtCD_opener = simd_and(LAngle_scope, lex.Exclam);
1246        CtCDPI_opener = simd_or(PI_opener, CtCD_opener);
1247        CD_closer = simd<1>::constant<0>();
1248        DoubleHyphen = simd_and(simd_and(v1, w1), lex.Hyphen);
1249        if ((bitblock::any(lex.RBracket) || carryQ.CarryTest(2, 2))) {
1250          carryQ.cq[2] = carryout2carry(pablo_blk_Advance(lex.RBracket, carryQ.get_carry_in(2), tempvar0));
1251          DoubleRBracket = simd_and(tempvar0, lex.RBracket);
1252          carryQ.cq[3] = carryout2carry(pablo_blk_Advance(DoubleRBracket, carryQ.get_carry_in(3), tempvar1));
1253          CD_closer = simd_and(tempvar1, lex.RAngle);
1254        }
1255        else {
1256          carryQ.CarryDequeueEnqueue(2, 2);
1257        }
1258        PI_closer = simd_and(simd_andc(w1, v1), lex.RAngle);
1259        carryQ.cq[4] = carryout2carry(pablo_blk_ScanToFirst(CtCDPI_opener, carryQ.get_carry_in(4), CtCDPI_Cursor));
1260        if ((bitblock::any(CtCDPI_Cursor) || carryQ.CarryTest(5, 13))) {
1261          CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
1262          PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
1263          carryQ.cq[5] = carryout2carry(pablo_blk_Advance(simd_andc(CtCDPI_Cursor, PI_Cursor), carryQ.get_carry_in(5), CD_Ct_Cursor));
1264          CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
1265          Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
1266          if ((bitblock::any(PI_Cursor) || carryQ.CarryTest(6, 4))) {
1267            ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
1268            carryQ.cq[6] = carryout2carry(pablo_blk_Advance(PI_Cursor, carryQ.get_carry_in(6), PI_Cursor));
1269            ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
1270            carryQ.cq[7] = carryout2carry(pablo_blk_ScanThru(PI_Cursor, lex.NameScan, carryQ.get_carry_in(7), PI_name_end));
1271            PI_error = simd_and(PI_Cursor, PI_name_end);
1272            PI_noWS = simd_andc(PI_name_end, lex.WS);
1273            carryQ.cq[8] = carryout2carry(pablo_blk_Advance(PI_noWS, carryQ.get_carry_in(8), tempvar2));
1274            PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(tempvar2, PI_closer)));
1275            if (bitblock::any(PI_error)) {
1276              assert_0_error("Error in PI syntax", PI_error);
1277            }
1278            ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
1279            carryQ.cq[9] = carryout2carry(pablo_blk_ScanThru(PI_name_end, simd_not(PI_closer), carryQ.get_carry_in(9), PI_Cursor));
1280            ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
1281            CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
1282          }
1283          else {
1284            carryQ.CarryDequeueEnqueue(6, 4);
1285          }
1286          if ((bitblock::any(CD_Cursor) || carryQ.CarryTest(10, 1))) {
1287            ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
1288            carryQ.cq[10] = carryout2carry(pablo_blk_ScanThru(CD_Cursor, simd_not(CD_closer), carryQ.get_carry_in(10), CD_Cursor));
1289            ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
1290            CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
1291          }
1292          else {
1293            carryQ.CarryDequeueEnqueue(10, 1);
1294          }
1295          if ((bitblock::any(Ct_Cursor) || carryQ.CarryTest(11, 5))) {
1296            ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
1297            carryQ.cq[11] = carryout2carry(pablo_blk_Advance(Ct_Cursor, carryQ.get_carry_in(11), Ct_Cursor));
1298            Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
1299            carryQ.cq[12] = carryout2carry(pablo_blk_Advance(Ct_Cursor, carryQ.get_carry_in(12), tempvar3));
1300            carryQ.cq[13] = carryout2carry(pablo_blk_Advance(tempvar3, carryQ.get_carry_in(13), Ct_Cursor));
1301            carryQ.cq[14] = carryout2carry(pablo_blk_ScanThru(Ct_Cursor, simd_not(DoubleHyphen), carryQ.get_carry_in(14), tempvar4));
1302            carryQ.cq[15] = carryout2carry(pablo_blk_Advance(tempvar4, carryQ.get_carry_in(15), Ct_Cursor));
1303            if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)))) {
1304              assert_0_error("Error in comment syntax", simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)));
1305            }
1306            ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
1307            CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
1308          }
1309          else {
1310            carryQ.CarryDequeueEnqueue(11, 5);
1311          }
1312          CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
1313          carryQ.cq[16] = carryout2carry(pablo_blk_InclusiveSpan(CtCDPI_starts, CtCDPI_ends, carryQ.get_carry_in(16), ctCDPI_mask));
1314          if (bitblock::any(simd<1>::constant<0>())) {
1315            assert_0_error("Error in comment, CDATA or processing instruction syntax", simd<1>::constant<0>());
1316          }
1317          carryQ.cq[17] = carryout2carry(pablo_blk_ScanThru(CtCDPI_Cursor, simd_not(CtCDPI_opener), carryQ.get_carry_in(17), CtCDPI_Cursor));
1318          while (bitblock::any(CtCDPI_Cursor)) {
1319            LocalCarryDeclare(subcarryQ, 13);
1320            CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
1321            PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
1322            subcarryQ.cq[0] = carryout2carry(pablo_blk_Advance(simd_andc(CtCDPI_Cursor, PI_Cursor), carry_value_0, CD_Ct_Cursor));
1323            CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
1324            Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
1325            if (bitblock::any(PI_Cursor)) {
1326              ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
1327              subcarryQ.cq[1] = carryout2carry(pablo_blk_Advance(PI_Cursor, carry_value_0, PI_Cursor));
1328              ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
1329              subcarryQ.cq[2] = carryout2carry(pablo_blk_ScanThru(PI_Cursor, lex.NameScan, carry_value_0, PI_name_end));
1330              PI_error = simd_and(PI_Cursor, PI_name_end);
1331              PI_noWS = simd_andc(PI_name_end, lex.WS);
1332              subcarryQ.cq[3] = carryout2carry(pablo_blk_Advance(PI_noWS, carry_value_0, tempvar2));
1333              PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(tempvar2, PI_closer)));
1334              if (bitblock::any(PI_error)) {
1335                assert_0_error("Error in PI syntax", PI_error);
1336              }
1337              ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
1338              subcarryQ.cq[4] = carryout2carry(pablo_blk_ScanThru(PI_name_end, simd_not(PI_closer), carry_value_0, PI_Cursor));
1339              ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
1340              CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
1341            }
1342            else {
1343              subcarryQ.CarryDequeueEnqueue(6, 4);
1344            }
1345            if (bitblock::any(CD_Cursor)) {
1346              ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
1347              subcarryQ.cq[5] = carryout2carry(pablo_blk_ScanThru(CD_Cursor, simd_not(CD_closer), carry_value_0, CD_Cursor));
1348              ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
1349              CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
1350            }
1351            else {
1352              subcarryQ.CarryDequeueEnqueue(10, 1);
1353            }
1354            if (bitblock::any(Ct_Cursor)) {
1355              ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
1356              subcarryQ.cq[6] = carryout2carry(pablo_blk_Advance(Ct_Cursor, carry_value_0, Ct_Cursor));
1357              Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
1358              subcarryQ.cq[7] = carryout2carry(pablo_blk_Advance(Ct_Cursor, carry_value_0, tempvar3));
1359              subcarryQ.cq[8] = carryout2carry(pablo_blk_Advance(tempvar3, carry_value_0, Ct_Cursor));
1360              subcarryQ.cq[9] = carryout2carry(pablo_blk_ScanThru(Ct_Cursor, simd_not(DoubleHyphen), carry_value_0, tempvar4));
1361              subcarryQ.cq[10] = carryout2carry(pablo_blk_Advance(tempvar4, carry_value_0, Ct_Cursor));
1362              if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)))) {
1363                assert_0_error("Error in comment syntax", simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)));
1364              }
1365              ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
1366              CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
1367            }
1368            else {
1369              subcarryQ.CarryDequeueEnqueue(11, 5);
1370            }
1371            CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
1372            subcarryQ.cq[11] = carryout2carry(pablo_blk_InclusiveSpan(CtCDPI_starts, CtCDPI_ends, carry_value_0, ctCDPI_mask));
1373            if (bitblock::any(simd<1>::constant<0>())) {
1374              assert_0_error("Error in comment, CDATA or processing instruction syntax", simd<1>::constant<0>());
1375            }
1376            subcarryQ.cq[12] = carryout2carry(pablo_blk_ScanThru(CtCDPI_Cursor, simd_not(CtCDPI_opener), carry_value_0, CtCDPI_Cursor));
1377            carryQ.CarryCombine(subcarryQ.cq, 5, 13);
1378          }
1379        }
1380        else {
1381          carryQ.CarryDequeueEnqueue(5, 13);
1382        }
1383        carryQ.cq[18] = carryout2carry(pablo_blk_InclusiveSpan(simd_or(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), simd_or(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carryQ.get_carry_in(18), tempvar5));
1384        check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS, lex.LAngle), tempvar5), CtCDPI_starts), EOF_mask);
1385        marker.LAngle_scope = simd_andc(LAngle_scope, ctCDPI_mask);
1386        marker.Ref_opener = simd_andc(lex.RefStart, ctCDPI_mask);
1387        marker.CD_closer = simd_andc(CD_closer, ctCDPI_mask);
1388        carryQ.CarryQ_Adjust(17);
1389  }
1390  IDISA_INLINE void clear() { 
1391carryQ.cq[4] = carryQ.carry_flip(carryQ.cq[4]);
1392 }
1393  void do_final_block(Lex & lex, Marker & marker, CtCDPI_Callouts & ctCDPI_Callouts, Check_streams & check_streams, BitBlock EOF_mask) {
1394                BitBlock CtCDPI_starts, CtCDPI_ends, ctCDPI_mask, v, w, v1, w1, LAngle_scope;
1395                BitBlock PI_opener, CtCD_opener, CtCDPI_opener, CD_closer, DoubleHyphen;
1396                BitBlock DoubleRBracket, PI_closer, CtCDPI_Cursor, PI_Cursor, CD_Ct_Cursor;
1397                BitBlock CD_Cursor, Ct_Cursor, PI_name_end, PI_error, PI_noWS, Ct_error;
1398
1399                BitBlock tempvar0, tempvar1, tempvar2, tempvar3, tempvar4, tempvar5;
1400
1401
1402        ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
1403        ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
1404        ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
1405        ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
1406        ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
1407        ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
1408        ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
1409        ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
1410        CtCDPI_starts = simd<1>::constant<0>();
1411        CtCDPI_ends = simd<1>::constant<0>();
1412        ctCDPI_mask = simd<1>::constant<0>();
1413        v = simd_or(lex.LAngle, lex.Hyphen);
1414        w = simd_or(lex.Hyphen, lex.QMark);
1415        carryQ.cq[0] = carryout2carry(pablo_blk_Advance(v, carryQ.get_carry_in(0), v1));
1416        carryQ.cq[1] = carryout2carry(pablo_blk_Advance(w, carryQ.get_carry_in(1), w1));
1417        LAngle_scope = simd_andc(v1, w1);
1418        PI_opener = simd_and(LAngle_scope, lex.QMark);
1419        CtCD_opener = simd_and(LAngle_scope, lex.Exclam);
1420        CtCDPI_opener = simd_or(PI_opener, CtCD_opener);
1421        CD_closer = simd<1>::constant<0>();
1422        DoubleHyphen = simd_and(simd_and(v1, w1), lex.Hyphen);
1423        if ((bitblock::any(lex.RBracket) || carryQ.CarryTest(2, 2))) {
1424          carryQ.cq[2] = carryout2carry(pablo_blk_Advance(lex.RBracket, carryQ.get_carry_in(2), tempvar0));
1425          DoubleRBracket = simd_and(tempvar0, lex.RBracket);
1426          carryQ.cq[3] = carryout2carry(pablo_blk_Advance(DoubleRBracket, carryQ.get_carry_in(3), tempvar1));
1427          CD_closer = simd_and(tempvar1, lex.RAngle);
1428        }
1429        else {
1430          carryQ.CarryDequeueEnqueue(2, 2);
1431        }
1432        PI_closer = simd_and(simd_andc(w1, v1), lex.RAngle);
1433        carryQ.cq[4] = carryout2carry(pablo_blk_ScanToFirst(CtCDPI_opener, carryQ.get_carry_in(4), CtCDPI_Cursor));
1434        if ((bitblock::any(simd_and(CtCDPI_Cursor, EOF_mask)) || carryQ.CarryTest(5, 13))) {
1435          CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
1436          PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
1437          carryQ.cq[5] = carryout2carry(pablo_blk_Advance(simd_andc(CtCDPI_Cursor, PI_Cursor), carryQ.get_carry_in(5), CD_Ct_Cursor));
1438          CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
1439          Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
1440          if ((bitblock::any(PI_Cursor) || carryQ.CarryTest(6, 4))) {
1441            ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
1442            carryQ.cq[6] = carryout2carry(pablo_blk_Advance(PI_Cursor, carryQ.get_carry_in(6), PI_Cursor));
1443            ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
1444            carryQ.cq[7] = carryout2carry(pablo_blk_ScanThru(PI_Cursor, lex.NameScan, carryQ.get_carry_in(7), PI_name_end));
1445            PI_error = simd_and(PI_Cursor, PI_name_end);
1446            PI_noWS = simd_andc(PI_name_end, lex.WS);
1447            carryQ.cq[8] = carryout2carry(pablo_blk_Advance(PI_noWS, carryQ.get_carry_in(8), tempvar2));
1448            PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(tempvar2, PI_closer)));
1449            if (bitblock::any(PI_error)) {
1450              assert_0_error("Error in PI syntax", PI_error);
1451            }
1452            ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
1453            carryQ.cq[9] = carryout2carry(pablo_blk_ScanThru(PI_name_end, simd_andc(EOF_mask, PI_closer), carryQ.get_carry_in(9), PI_Cursor));
1454            ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
1455            CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
1456          }
1457          else {
1458            carryQ.CarryDequeueEnqueue(6, 4);
1459          }
1460          if ((bitblock::any(CD_Cursor) || carryQ.CarryTest(10, 1))) {
1461            ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
1462            carryQ.cq[10] = carryout2carry(pablo_blk_ScanThru(CD_Cursor, simd_andc(EOF_mask, CD_closer), carryQ.get_carry_in(10), CD_Cursor));
1463            ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
1464            CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
1465          }
1466          else {
1467            carryQ.CarryDequeueEnqueue(10, 1);
1468          }
1469          if ((bitblock::any(Ct_Cursor) || carryQ.CarryTest(11, 5))) {
1470            ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
1471            carryQ.cq[11] = carryout2carry(pablo_blk_Advance(Ct_Cursor, carryQ.get_carry_in(11), Ct_Cursor));
1472            Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
1473            carryQ.cq[12] = carryout2carry(pablo_blk_Advance(Ct_Cursor, carryQ.get_carry_in(12), tempvar3));
1474            carryQ.cq[13] = carryout2carry(pablo_blk_Advance(tempvar3, carryQ.get_carry_in(13), Ct_Cursor));
1475            carryQ.cq[14] = carryout2carry(pablo_blk_ScanThru(Ct_Cursor, simd_andc(EOF_mask, DoubleHyphen), carryQ.get_carry_in(14), tempvar4));
1476            carryQ.cq[15] = carryout2carry(pablo_blk_Advance(tempvar4, carryQ.get_carry_in(15), Ct_Cursor));
1477            if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)))) {
1478              assert_0_error("Error in comment syntax", simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)));
1479            }
1480            ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
1481            CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
1482          }
1483          else {
1484            carryQ.CarryDequeueEnqueue(11, 5);
1485          }
1486          CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
1487          carryQ.cq[16] = carryout2carry(pablo_blk_InclusiveSpan(CtCDPI_starts, CtCDPI_ends, carryQ.get_carry_in(16), ctCDPI_mask));
1488          if (bitblock::any(simd_andc(simd_andc(ctCDPI_mask, EOF_mask), bitblock::slli<1>(simd_not(EOF_mask))))) {
1489            assert_0_error("Error in comment, CDATA or processing instruction syntax", simd_andc(simd_andc(ctCDPI_mask, EOF_mask), bitblock::slli<1>(simd_not(EOF_mask))));
1490          }
1491          carryQ.cq[17] = carryout2carry(pablo_blk_ScanThru(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), carryQ.get_carry_in(17), CtCDPI_Cursor));
1492          while (bitblock::any(simd_and(CtCDPI_Cursor, EOF_mask))) {
1493            LocalCarryDeclare(subcarryQ, 13);
1494            CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
1495            PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
1496            subcarryQ.cq[0] = carryout2carry(pablo_blk_Advance(simd_andc(CtCDPI_Cursor, PI_Cursor), carry_value_0, CD_Ct_Cursor));
1497            CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
1498            Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
1499            if (bitblock::any(PI_Cursor)) {
1500              ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
1501              subcarryQ.cq[1] = carryout2carry(pablo_blk_Advance(PI_Cursor, carry_value_0, PI_Cursor));
1502              ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
1503              subcarryQ.cq[2] = carryout2carry(pablo_blk_ScanThru(PI_Cursor, lex.NameScan, carry_value_0, PI_name_end));
1504              PI_error = simd_and(PI_Cursor, PI_name_end);
1505              PI_noWS = simd_andc(PI_name_end, lex.WS);
1506              subcarryQ.cq[3] = carryout2carry(pablo_blk_Advance(PI_noWS, carry_value_0, tempvar2));
1507              PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(tempvar2, PI_closer)));
1508              if (bitblock::any(PI_error)) {
1509                assert_0_error("Error in PI syntax", PI_error);
1510              }
1511              ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
1512              subcarryQ.cq[4] = carryout2carry(pablo_blk_ScanThru(PI_name_end, simd_andc(EOF_mask, PI_closer), carry_value_0, PI_Cursor));
1513              ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
1514              CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
1515            }
1516            else {
1517              subcarryQ.CarryDequeueEnqueue(6, 4);
1518            }
1519            if (bitblock::any(CD_Cursor)) {
1520              ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
1521              subcarryQ.cq[5] = carryout2carry(pablo_blk_ScanThru(CD_Cursor, simd_andc(EOF_mask, CD_closer), carry_value_0, CD_Cursor));
1522              ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
1523              CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
1524            }
1525            else {
1526              subcarryQ.CarryDequeueEnqueue(10, 1);
1527            }
1528            if (bitblock::any(Ct_Cursor)) {
1529              ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
1530              subcarryQ.cq[6] = carryout2carry(pablo_blk_Advance(Ct_Cursor, carry_value_0, Ct_Cursor));
1531              Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
1532              subcarryQ.cq[7] = carryout2carry(pablo_blk_Advance(Ct_Cursor, carry_value_0, tempvar3));
1533              subcarryQ.cq[8] = carryout2carry(pablo_blk_Advance(tempvar3, carry_value_0, Ct_Cursor));
1534              subcarryQ.cq[9] = carryout2carry(pablo_blk_ScanThru(Ct_Cursor, simd_andc(EOF_mask, DoubleHyphen), carry_value_0, tempvar4));
1535              subcarryQ.cq[10] = carryout2carry(pablo_blk_Advance(tempvar4, carry_value_0, Ct_Cursor));
1536              if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)))) {
1537                assert_0_error("Error in comment syntax", simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)));
1538              }
1539              ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
1540              CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
1541            }
1542            else {
1543              subcarryQ.CarryDequeueEnqueue(11, 5);
1544            }
1545            CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
1546            subcarryQ.cq[11] = carryout2carry(pablo_blk_InclusiveSpan(CtCDPI_starts, CtCDPI_ends, carry_value_0, ctCDPI_mask));
1547            if (bitblock::any(simd_andc(simd_andc(ctCDPI_mask, EOF_mask), bitblock::slli<1>(simd_not(EOF_mask))))) {
1548              assert_0_error("Error in comment, CDATA or processing instruction syntax", simd_andc(simd_andc(ctCDPI_mask, EOF_mask), bitblock::slli<1>(simd_not(EOF_mask))));
1549            }
1550            subcarryQ.cq[12] = carryout2carry(pablo_blk_ScanThru(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), carry_value_0, CtCDPI_Cursor));
1551            carryQ.CarryCombine(subcarryQ.cq, 5, 13);
1552          }
1553        }
1554        else {
1555          carryQ.CarryDequeueEnqueue(5, 13);
1556        }
1557        carryQ.cq[18] = carryout2carry(pablo_blk_InclusiveSpan(simd_or(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), simd_or(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carryQ.get_carry_in(18), tempvar5));
1558        check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS, lex.LAngle), tempvar5), CtCDPI_starts), EOF_mask);
1559        marker.LAngle_scope = simd_andc(LAngle_scope, ctCDPI_mask);
1560        marker.Ref_opener = simd_andc(lex.RefStart, ctCDPI_mask);
1561        marker.CD_closer = simd_andc(CD_closer, ctCDPI_mask);
1562  }
1563  CarryArray<19, 0> carryQ;
1564  };
1565
1566  struct Validation_9 {
1567  Validation_9() { 
1568 }
1569  IDISA_INLINE void do_block(Lex & lex, Output & output) {
1570                BitBlock m0, m1, m2;
1571
1572
1573
1574
1575        m0 = simd<1>::constant<0>();
1576        m1 = simd<1>::constant<0>();
1577        m2 = simd<1>::constant<0>();
1578        m0 = simd_not(simd<1>::constant<0>());
1579        carryQ.cq[0] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc9), carryQ.get_carry_in(0), m0));
1580        carryQ.cq[1] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc10), carryQ.get_carry_in(1), m0));
1581        carryQ.cq[2] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(2), m0));
1582        m1 = m0;
1583        carryQ.cq[3] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.cc11), carryQ.get_carry_in(3), m1));
1584        carryQ.cq[4] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.tag_closing), carryQ.get_carry_in(4), m1));
1585        m0 = simd_or(m0, m1);
1586        carryQ.cq[5] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc12), carryQ.get_carry_in(5), m0));
1587        carryQ.cq[6] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(6), m0));
1588        carryQ.cq[7] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc13), carryQ.get_carry_in(7), m0));
1589        carryQ.cq[8] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(8), m0));
1590        carryQ.cq[9] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(9), m0));
1591        output.matches = m0;
1592        output.matches = simd_xor(m0, lex.cc9);
1593        if (bitblock::any(output.matches)) {
1594          error_tracker.NoteError("Element_9 error found", output.matches);
1595        }
1596        carryQ.CarryQ_Adjust(10);
1597  }
1598  IDISA_INLINE void clear() { 
1599 }
1600  void do_final_block(Lex & lex, Output & output, BitBlock EOF_mask) {
1601                BitBlock m0, m1, m2;
1602
1603
1604
1605
1606        m0 = simd<1>::constant<0>();
1607        m1 = simd<1>::constant<0>();
1608        m2 = simd<1>::constant<0>();
1609        m0 = simd_not(simd<1>::constant<0>());
1610        carryQ.cq[0] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc9), carryQ.get_carry_in(0), m0));
1611        carryQ.cq[1] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc10), carryQ.get_carry_in(1), m0));
1612        carryQ.cq[2] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(2), m0));
1613        m1 = m0;
1614        carryQ.cq[3] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.cc11), carryQ.get_carry_in(3), m1));
1615        carryQ.cq[4] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.tag_closing), carryQ.get_carry_in(4), m1));
1616        m0 = simd_or(m0, m1);
1617        carryQ.cq[5] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc12), carryQ.get_carry_in(5), m0));
1618        carryQ.cq[6] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(6), m0));
1619        carryQ.cq[7] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc13), carryQ.get_carry_in(7), m0));
1620        carryQ.cq[8] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(8), m0));
1621        carryQ.cq[9] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(9), m0));
1622        output.matches = m0;
1623        output.matches = simd_xor(m0, lex.cc9);
1624        if (bitblock::any(output.matches)) {
1625          error_tracker.NoteError("Element_9 error found", output.matches);
1626        }
1627  }
1628  CarryArray<10, 0> carryQ;
1629  };
1630
1631  struct Do_check_streams {
1632 
1633  IDISA_INLINE void do_block(Marker & marker, Tag_Callouts & tag_Callouts, Check_streams & check_streams) {
1634
1635
1636
1637
1638
1639        if (bitblock::any(simd_andc(marker.CD_closer, tag_Callouts.AttVal_spans))) {
1640          assert_0_error("Error: ]]> in text", simd_andc(marker.CD_closer, tag_Callouts.AttVal_spans));
1641        }
1642        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);
1643        check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends, tag_Callouts.AttName_ends);
1644        check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans, marker.Ref_opener);
1645  }
1646  IDISA_INLINE void clear() { 
1647 }
1648  void do_final_block(Marker & marker, Tag_Callouts & tag_Callouts, Check_streams & check_streams, BitBlock EOF_mask) {
1649
1650
1651
1652
1653
1654        if (bitblock::any(simd_andc(marker.CD_closer, tag_Callouts.AttVal_spans))) {
1655          assert_0_error("Error: ]]> in text", simd_andc(marker.CD_closer, tag_Callouts.AttVal_spans));
1656        }
1657        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);
1658        check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends, tag_Callouts.AttName_ends);
1659        check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans, marker.Ref_opener);
1660  }
1661 
1662  };
1663
1664  struct Classify_bytes {
1665 
1666  IDISA_INLINE void do_block(Basis_bits & basis_bits, Lex & lex) {
1667                BitBlock temp1, temp2, temp3, temp4, temp5, temp6, temp7, temp8, temp9, temp10;
1668                BitBlock temp11, temp12, temp13, temp14, temp15, temp16, temp17, temp18;
1669                BitBlock temp19, temp20, temp21, temp22, temp23, temp24, temp25, temp26;
1670
1671
1672
1673
1674        temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
1675        temp2 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
1676        temp3 = simd_or(temp1, temp2);
1677        temp4 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
1678        temp5 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
1679        temp6 = simd_andc(temp5, temp4);
1680        lex.cc1 = simd_andc(temp6, temp3);
1681        temp7 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
1682        temp8 = simd_andc(temp7, temp4);
1683        lex.cc2 = simd_andc(temp8, temp3);
1684        temp9 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
1685        temp10 = simd_andc(temp9, temp4);
1686        lex.cc3 = simd_andc(temp10, temp3);
1687        temp11 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
1688        temp12 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
1689        temp13 = simd_andc(temp11, temp12);
1690        lex.cc4 = simd_andc(temp13, temp3);
1691        temp14 = simd_and(temp11, temp5);
1692        lex.cc5 = simd_andc(temp14, temp3);
1693        temp15 = simd_and(temp11, temp7);
1694        lex.cc6 = simd_andc(temp15, temp3);
1695        temp16 = simd_and(temp11, temp9);
1696        lex.cc7 = simd_andc(temp16, temp3);
1697        temp17 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
1698        temp18 = simd_andc(temp17, temp12);
1699        lex.cc8 = simd_andc(temp18, temp3);
1700        temp19 = simd_and(temp17, temp5);
1701        lex.cc9 = simd_andc(temp19, temp3);
1702        temp20 = simd_and(temp17, temp7);
1703        lex.cc10 = simd_andc(temp20, temp3);
1704        temp21 = simd_and(temp17, temp9);
1705        lex.cc11 = simd_andc(temp21, temp3);
1706        temp22 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
1707        temp23 = simd_andc(temp22, temp12);
1708        lex.cc12 = simd_andc(temp23, temp3);
1709        temp24 = simd_and(temp22, temp5);
1710        lex.cc13 = simd_andc(temp24, temp3);
1711        temp25 = simd_or(temp4, temp12);
1712        temp26 = simd_or(temp3, temp25);
1713        lex.tag_closing = simd_not(temp26);
1714  }
1715  IDISA_INLINE void clear() { 
1716 }
1717  void do_final_block(Basis_bits & basis_bits, Lex & lex, BitBlock EOF_mask) {
1718                BitBlock temp1, temp2, temp3, temp4, temp5, temp6, temp7, temp8, temp9, temp10;
1719                BitBlock temp11, temp12, temp13, temp14, temp15, temp16, temp17, temp18;
1720                BitBlock temp19, temp20, temp21, temp22, temp23, temp24, temp25, temp26;
1721
1722
1723
1724
1725        temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
1726        temp2 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
1727        temp3 = simd_or(temp1, temp2);
1728        temp4 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
1729        temp5 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
1730        temp6 = simd_andc(temp5, temp4);
1731        lex.cc1 = simd_andc(temp6, temp3);
1732        temp7 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
1733        temp8 = simd_andc(temp7, temp4);
1734        lex.cc2 = simd_andc(temp8, temp3);
1735        temp9 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
1736        temp10 = simd_andc(temp9, temp4);
1737        lex.cc3 = simd_andc(temp10, temp3);
1738        temp11 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
1739        temp12 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
1740        temp13 = simd_andc(temp11, temp12);
1741        lex.cc4 = simd_andc(temp13, temp3);
1742        temp14 = simd_and(temp11, temp5);
1743        lex.cc5 = simd_andc(temp14, temp3);
1744        temp15 = simd_and(temp11, temp7);
1745        lex.cc6 = simd_andc(temp15, temp3);
1746        temp16 = simd_and(temp11, temp9);
1747        lex.cc7 = simd_andc(temp16, temp3);
1748        temp17 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
1749        temp18 = simd_andc(temp17, temp12);
1750        lex.cc8 = simd_andc(temp18, temp3);
1751        temp19 = simd_and(temp17, temp5);
1752        lex.cc9 = simd_andc(temp19, temp3);
1753        temp20 = simd_and(temp17, temp7);
1754        lex.cc10 = simd_andc(temp20, temp3);
1755        temp21 = simd_and(temp17, temp9);
1756        lex.cc11 = simd_andc(temp21, temp3);
1757        temp22 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
1758        temp23 = simd_andc(temp22, temp12);
1759        lex.cc12 = simd_andc(temp23, temp3);
1760        temp24 = simd_and(temp22, temp5);
1761        lex.cc13 = simd_andc(temp24, temp3);
1762        temp25 = simd_or(temp4, temp12);
1763        temp26 = simd_or(temp3, temp25);
1764        lex.tag_closing = simd_not(temp26);
1765  }
1766 
1767  };
1768
1769  struct Validation_2 {
1770  Validation_2() { 
1771 }
1772  IDISA_INLINE void do_block(Lex & lex, Output & output) {
1773                BitBlock m0, m1, m2;
1774
1775
1776
1777
1778        m0 = simd<1>::constant<0>();
1779        m1 = simd<1>::constant<0>();
1780        m2 = simd<1>::constant<0>();
1781        m0 = simd_not(simd<1>::constant<0>());
1782        carryQ.cq[0] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc2), carryQ.get_carry_in(0), m0));
1783        carryQ.cq[1] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc3), carryQ.get_carry_in(1), m0));
1784        carryQ.cq[2] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(2), m0));
1785        carryQ.cq[3] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc4), carryQ.get_carry_in(3), m0));
1786        carryQ.cq[4] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(4), m0));
1787        m1 = m0;
1788        carryQ.cq[5] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.cc9), carryQ.get_carry_in(5), m1));
1789        carryQ.cq[6] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.tag_closing), carryQ.get_carry_in(6), m1));
1790        m0 = m1;
1791        m1 = m0;
1792        carryQ.cq[7] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.cc9), carryQ.get_carry_in(7), m1));
1793        carryQ.cq[8] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.tag_closing), carryQ.get_carry_in(8), m1));
1794        if ((bitblock::any(simd_andc(m1, m0)) || carryQ.CarryTest(9, 2))) {
1795          m0 = simd_or(m0, m1);
1796          carryQ.cq[9] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.cc9), carryQ.get_carry_in(9), m1));
1797          carryQ.cq[10] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.tag_closing), carryQ.get_carry_in(10), m1));
1798          while (bitblock::any(simd_andc(m1, m0))) {
1799            LocalCarryDeclare(subcarryQ, 2);
1800            m0 = simd_or(m0, m1);
1801            subcarryQ.cq[0] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.cc9), carry_value_0, m1));
1802            subcarryQ.cq[1] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.tag_closing), carry_value_0, m1));
1803            carryQ.CarryCombine(subcarryQ.cq, 9, 2);
1804          }
1805        }
1806        else {
1807          carryQ.CarryDequeueEnqueue(9, 2);
1808        }
1809        carryQ.cq[11] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(11), m0));
1810        output.matches = m0;
1811        output.matches = simd_xor(m0, lex.cc2);
1812        if (bitblock::any(output.matches)) {
1813          error_tracker.NoteError("Element_2 error found", output.matches);
1814        }
1815        carryQ.CarryQ_Adjust(12);
1816  }
1817  IDISA_INLINE void clear() { 
1818 }
1819  void do_final_block(Lex & lex, Output & output, BitBlock EOF_mask) {
1820                BitBlock m0, m1, m2;
1821
1822
1823
1824
1825        m0 = simd<1>::constant<0>();
1826        m1 = simd<1>::constant<0>();
1827        m2 = simd<1>::constant<0>();
1828        m0 = simd_not(simd<1>::constant<0>());
1829        carryQ.cq[0] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc2), carryQ.get_carry_in(0), m0));
1830        carryQ.cq[1] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc3), carryQ.get_carry_in(1), m0));
1831        carryQ.cq[2] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(2), m0));
1832        carryQ.cq[3] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc4), carryQ.get_carry_in(3), m0));
1833        carryQ.cq[4] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(4), m0));
1834        m1 = m0;
1835        carryQ.cq[5] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.cc9), carryQ.get_carry_in(5), m1));
1836        carryQ.cq[6] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.tag_closing), carryQ.get_carry_in(6), m1));
1837        m0 = m1;
1838        m1 = m0;
1839        carryQ.cq[7] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.cc9), carryQ.get_carry_in(7), m1));
1840        carryQ.cq[8] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.tag_closing), carryQ.get_carry_in(8), m1));
1841        if ((bitblock::any(simd_and(simd_andc(m1, m0), EOF_mask)) || carryQ.CarryTest(9, 2))) {
1842          m0 = simd_or(m0, m1);
1843          carryQ.cq[9] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.cc9), carryQ.get_carry_in(9), m1));
1844          carryQ.cq[10] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.tag_closing), carryQ.get_carry_in(10), m1));
1845          while (bitblock::any(simd_and(simd_andc(m1, m0), EOF_mask))) {
1846            LocalCarryDeclare(subcarryQ, 2);
1847            m0 = simd_or(m0, m1);
1848            subcarryQ.cq[0] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.cc9), carry_value_0, m1));
1849            subcarryQ.cq[1] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.tag_closing), carry_value_0, m1));
1850            carryQ.CarryCombine(subcarryQ.cq, 9, 2);
1851          }
1852        }
1853        else {
1854          carryQ.CarryDequeueEnqueue(9, 2);
1855        }
1856        carryQ.cq[11] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(11), m0));
1857        output.matches = m0;
1858        output.matches = simd_xor(m0, lex.cc2);
1859        if (bitblock::any(output.matches)) {
1860          error_tracker.NoteError("Element_2 error found", output.matches);
1861        }
1862  }
1863  CarryArray<12, 0> carryQ;
1864  };
1865
1866  struct Validate_xml_names {
1867  Validate_xml_names() { 
1868 }
1869  IDISA_INLINE void do_block(CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Tag_Callouts & tag_Callouts, Lex & lex, U8 & u8, Check_streams & check_streams) {
1870                BitBlock PI_names, GenRefs, ElemNames, AttNames, qname_stream, ncname_stream;
1871                BitBlock name_stream, name_start, name_cursor, void_prefix_err, namespace_sep;
1872                BitBlock local_part_start, local_part_err, colon2_err, ncname_err;
1873                BitBlock namespace_error;
1874
1875                BitBlock tempvar0, tempvar1, tempvar2, tempvar3;
1876
1877
1878        carryQ.cq[0] = carryout2carry(pablo_blk_SpanUpTo(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carryQ.get_carry_in(0), PI_names));
1879        carryQ.cq[1] = carryout2carry(pablo_blk_SpanUpTo(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carryQ.get_carry_in(1), GenRefs));
1880        carryQ.cq[2] = carryout2carry(pablo_blk_SpanUpTo(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carryQ.get_carry_in(2), ElemNames));
1881        carryQ.cq[3] = carryout2carry(pablo_blk_SpanUpTo(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carryQ.get_carry_in(3), AttNames));
1882        qname_stream = simd_or(ElemNames, AttNames);
1883        ncname_stream = simd_or(PI_names, GenRefs);
1884        name_stream = simd_or(qname_stream, ncname_stream);
1885        carryQ.cq[4] = carryout2carry(pablo_blk_Advance(name_stream, carryQ.get_carry_in(4), tempvar0));
1886        name_start = simd_andc(name_stream, tempvar0);
1887        carryQ.cq[5] = carryout2carry(pablo_blk_Advance(name_stream, carryQ.get_carry_in(5), tempvar1));
1888        name_cursor = simd_andc(name_stream, tempvar1);
1889        void_prefix_err = simd_and(name_cursor, lex.Colon);
1890        carryQ.cq[6] = carryout2carry(pablo_blk_ScanThru(name_cursor, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(6), tempvar2));
1891        namespace_sep = simd_and(tempvar2, lex.Colon);
1892        carryQ.cq[7] = carryout2carry(pablo_blk_Advance(namespace_sep, carryQ.get_carry_in(7), local_part_start));
1893        local_part_err = simd_andc(local_part_start, lex.NameScan);
1894        carryQ.cq[8] = carryout2carry(pablo_blk_ScanThru(local_part_start, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(8), tempvar3));
1895        colon2_err = simd_and(tempvar3, lex.Colon);
1896        ncname_err = simd_and(ncname_stream, lex.Colon);
1897        namespace_error = simd_or(simd_or(simd_or(void_prefix_err, local_part_err), colon2_err), ncname_err);
1898        if (bitblock::any(namespace_error)) {
1899          error_tracker.NoteError("error found", namespace_error);
1900        }
1901        check_streams.non_ascii_name_starts = simd_andc(name_start, lex.ASCII_name_start);
1902        check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream, name_start), lex.ASCII_name_char), u8.suffix);
1903        carryQ.CarryQ_Adjust(9);
1904  }
1905  IDISA_INLINE void clear() { 
1906 }
1907  void do_final_block(CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Tag_Callouts & tag_Callouts, Lex & lex, U8 & u8, Check_streams & check_streams, BitBlock EOF_mask) {
1908                BitBlock PI_names, GenRefs, ElemNames, AttNames, qname_stream, ncname_stream;
1909                BitBlock name_stream, name_start, name_cursor, void_prefix_err, namespace_sep;
1910                BitBlock local_part_start, local_part_err, colon2_err, ncname_err;
1911                BitBlock namespace_error;
1912
1913                BitBlock tempvar0, tempvar1, tempvar2, tempvar3;
1914
1915
1916        carryQ.cq[0] = carryout2carry(pablo_blk_SpanUpTo(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carryQ.get_carry_in(0), PI_names));
1917        carryQ.cq[1] = carryout2carry(pablo_blk_SpanUpTo(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carryQ.get_carry_in(1), GenRefs));
1918        carryQ.cq[2] = carryout2carry(pablo_blk_SpanUpTo(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carryQ.get_carry_in(2), ElemNames));
1919        carryQ.cq[3] = carryout2carry(pablo_blk_SpanUpTo(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carryQ.get_carry_in(3), AttNames));
1920        qname_stream = simd_or(ElemNames, AttNames);
1921        ncname_stream = simd_or(PI_names, GenRefs);
1922        name_stream = simd_or(qname_stream, ncname_stream);
1923        carryQ.cq[4] = carryout2carry(pablo_blk_Advance(name_stream, carryQ.get_carry_in(4), tempvar0));
1924        name_start = simd_andc(name_stream, tempvar0);
1925        carryQ.cq[5] = carryout2carry(pablo_blk_Advance(name_stream, carryQ.get_carry_in(5), tempvar1));
1926        name_cursor = simd_andc(name_stream, tempvar1);
1927        void_prefix_err = simd_and(name_cursor, lex.Colon);
1928        carryQ.cq[6] = carryout2carry(pablo_blk_ScanThru(name_cursor, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(6), tempvar2));
1929        namespace_sep = simd_and(tempvar2, lex.Colon);
1930        carryQ.cq[7] = carryout2carry(pablo_blk_Advance(namespace_sep, carryQ.get_carry_in(7), local_part_start));
1931        local_part_err = simd_andc(local_part_start, lex.NameScan);
1932        carryQ.cq[8] = carryout2carry(pablo_blk_ScanThru(local_part_start, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(8), tempvar3));
1933        colon2_err = simd_and(tempvar3, lex.Colon);
1934        ncname_err = simd_and(ncname_stream, lex.Colon);
1935        namespace_error = simd_or(simd_or(simd_or(void_prefix_err, local_part_err), colon2_err), ncname_err);
1936        if (bitblock::any(namespace_error)) {
1937          error_tracker.NoteError("error found", namespace_error);
1938        }
1939        check_streams.non_ascii_name_starts = simd_andc(name_start, lex.ASCII_name_start);
1940        check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream, name_start), lex.ASCII_name_char), u8.suffix);
1941  }
1942  CarryArray<9, 0> carryQ;
1943  };
1944
1945  struct Validation_4 {
1946  Validation_4() { 
1947 }
1948  IDISA_INLINE void do_block(Lex & lex, Output & output) {
1949                BitBlock m0;
1950
1951
1952
1953
1954        m0 = simd<1>::constant<0>();
1955        m0 = simd_not(simd<1>::constant<0>());
1956        carryQ.cq[0] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc4), carryQ.get_carry_in(0), m0));
1957        carryQ.cq[1] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc5), carryQ.get_carry_in(1), m0));
1958        carryQ.cq[2] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(2), m0));
1959        carryQ.cq[3] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc6), carryQ.get_carry_in(3), m0));
1960        carryQ.cq[4] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(4), m0));
1961        carryQ.cq[5] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc7), carryQ.get_carry_in(5), m0));
1962        carryQ.cq[6] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(6), m0));
1963        carryQ.cq[7] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc8), carryQ.get_carry_in(7), m0));
1964        carryQ.cq[8] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(8), m0));
1965        carryQ.cq[9] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(9), m0));
1966        output.matches = m0;
1967        output.matches = simd_xor(m0, lex.cc4);
1968        if (bitblock::any(output.matches)) {
1969          error_tracker.NoteError("Element_4 error found", output.matches);
1970        }
1971        carryQ.CarryQ_Adjust(10);
1972  }
1973  IDISA_INLINE void clear() { 
1974 }
1975  void do_final_block(Lex & lex, Output & output, BitBlock EOF_mask) {
1976                BitBlock m0;
1977
1978
1979
1980
1981        m0 = simd<1>::constant<0>();
1982        m0 = simd_not(simd<1>::constant<0>());
1983        carryQ.cq[0] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc4), carryQ.get_carry_in(0), m0));
1984        carryQ.cq[1] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc5), carryQ.get_carry_in(1), m0));
1985        carryQ.cq[2] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(2), m0));
1986        carryQ.cq[3] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc6), carryQ.get_carry_in(3), m0));
1987        carryQ.cq[4] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(4), m0));
1988        carryQ.cq[5] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc7), carryQ.get_carry_in(5), m0));
1989        carryQ.cq[6] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(6), m0));
1990        carryQ.cq[7] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.cc8), carryQ.get_carry_in(7), m0));
1991        carryQ.cq[8] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(8), m0));
1992        carryQ.cq[9] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.tag_closing), carryQ.get_carry_in(9), m0));
1993        output.matches = m0;
1994        output.matches = simd_xor(m0, lex.cc4);
1995        if (bitblock::any(output.matches)) {
1996          error_tracker.NoteError("Element_4 error found", output.matches);
1997        }
1998  }
1999  CarryArray<10, 0> carryQ;
2000  };
2001
2002  struct Validate_content_5 {
2003  Validate_content_5() { 
2004 }
2005  IDISA_INLINE void do_block(Lex & lex, Output & output) {
2006                BitBlock m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15;
2007                BitBlock m16, m17, temp, all_matches;
2008
2009                BitBlock tempvar0;
2010
2011
2012        m0 = simd<1>::constant<0>();
2013        m1 = simd<1>::constant<0>();
2014        m2 = simd<1>::constant<0>();
2015        m3 = simd<1>::constant<0>();
2016        m4 = simd<1>::constant<0>();
2017        m5 = simd<1>::constant<0>();
2018        m6 = simd<1>::constant<0>();
2019        m7 = simd<1>::constant<0>();
2020        m8 = simd<1>::constant<0>();
2021        m9 = simd<1>::constant<0>();
2022        m10 = simd<1>::constant<0>();
2023        m11 = simd<1>::constant<0>();
2024        m12 = simd<1>::constant<0>();
2025        m13 = simd<1>::constant<0>();
2026        m14 = simd<1>::constant<0>();
2027        m15 = simd<1>::constant<0>();
2028        m16 = simd<1>::constant<0>();
2029        m17 = simd<1>::constant<0>();
2030        m0 = simd_not(simd<1>::constant<0>());
2031        m1 = m0;
2032        carryQ.cq[0] = carryout2carry(pablo_blk_Advance(lex.Caret, carryQ.get_carry_in(0), tempvar0));
2033        m0 = simd_andc(m0, tempvar0);
2034        carryQ.cq[1] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.content_end), carryQ.get_carry_in(1), m1));
2035        m0 = simd_or(m0, m1);
2036        m2 = m0;
2037        carryQ.cq[2] = carryout2carry(pablo_blk_Advance(simd_and(m2, lex.P_H_sign), carryQ.get_carry_in(2), m2));
2038        m0 = simd_or(m0, m2);
2039        carryQ.cq[3] = carryout2carry(pablo_blk_MatchStar(m0, lex.Digit, carryQ.get_carry_in(3), m0));
2040        m7 = m0;
2041        carryQ.cq[4] = carryout2carry(pablo_blk_Advance(simd_and(m7, lex.Dot), carryQ.get_carry_in(4), m7));
2042        m0 = simd_or(m0, m7);
2043        m9 = m0;
2044        carryQ.cq[5] = carryout2carry(pablo_blk_Advance(simd_and(m9, lex.Digit), carryQ.get_carry_in(5), m9));
2045        m0 = m9;
2046        carryQ.cq[6] = carryout2carry(pablo_blk_MatchStar(m0, lex.Digit, carryQ.get_carry_in(6), m0));
2047        output.tem = m9;
2048        temp = m0;
2049        m11 = m0;
2050        carryQ.cq[7] = carryout2carry(pablo_blk_Advance(simd_and(m11, lex.E_and_e), carryQ.get_carry_in(7), m11));
2051        m13 = m11;
2052        carryQ.cq[8] = carryout2carry(pablo_blk_Advance(simd_and(m13, lex.P_H_sign), carryQ.get_carry_in(8), m13));
2053        m11 = simd_or(m11, m13);
2054        m16 = m11;
2055        carryQ.cq[9] = carryout2carry(pablo_blk_Advance(simd_and(m16, lex.Digit), carryQ.get_carry_in(9), m16));
2056        m11 = m16;
2057        carryQ.cq[10] = carryout2carry(pablo_blk_MatchStar(m11, lex.Digit, carryQ.get_carry_in(10), m11));
2058        m0 = simd_or(m0, m11);
2059        carryQ.cq[11] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.content_end), carryQ.get_carry_in(11), m0));
2060        output.matches = simd<1>::constant<0>();
2061        all_matches = m0;
2062        output.matches = temp;
2063        carryQ.CarryQ_Adjust(12);
2064  }
2065  IDISA_INLINE void clear() { 
2066 }
2067  void do_final_block(Lex & lex, Output & output, BitBlock EOF_mask) {
2068                BitBlock m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15;
2069                BitBlock m16, m17, temp, all_matches;
2070
2071                BitBlock tempvar0;
2072
2073
2074        m0 = simd<1>::constant<0>();
2075        m1 = simd<1>::constant<0>();
2076        m2 = simd<1>::constant<0>();
2077        m3 = simd<1>::constant<0>();
2078        m4 = simd<1>::constant<0>();
2079        m5 = simd<1>::constant<0>();
2080        m6 = simd<1>::constant<0>();
2081        m7 = simd<1>::constant<0>();
2082        m8 = simd<1>::constant<0>();
2083        m9 = simd<1>::constant<0>();
2084        m10 = simd<1>::constant<0>();
2085        m11 = simd<1>::constant<0>();
2086        m12 = simd<1>::constant<0>();
2087        m13 = simd<1>::constant<0>();
2088        m14 = simd<1>::constant<0>();
2089        m15 = simd<1>::constant<0>();
2090        m16 = simd<1>::constant<0>();
2091        m17 = simd<1>::constant<0>();
2092        m0 = simd_not(simd<1>::constant<0>());
2093        m1 = m0;
2094        carryQ.cq[0] = carryout2carry(pablo_blk_Advance(lex.Caret, carryQ.get_carry_in(0), tempvar0));
2095        m0 = simd_andc(m0, tempvar0);
2096        carryQ.cq[1] = carryout2carry(pablo_blk_Advance(simd_and(m1, lex.content_end), carryQ.get_carry_in(1), m1));
2097        m0 = simd_or(m0, m1);
2098        m2 = m0;
2099        carryQ.cq[2] = carryout2carry(pablo_blk_Advance(simd_and(m2, lex.P_H_sign), carryQ.get_carry_in(2), m2));
2100        m0 = simd_or(m0, m2);
2101        carryQ.cq[3] = carryout2carry(pablo_blk_MatchStar(m0, lex.Digit, carryQ.get_carry_in(3), m0));
2102        m7 = m0;
2103        carryQ.cq[4] = carryout2carry(pablo_blk_Advance(simd_and(m7, lex.Dot), carryQ.get_carry_in(4), m7));
2104        m0 = simd_or(m0, m7);
2105        m9 = m0;
2106        carryQ.cq[5] = carryout2carry(pablo_blk_Advance(simd_and(m9, lex.Digit), carryQ.get_carry_in(5), m9));
2107        m0 = m9;
2108        carryQ.cq[6] = carryout2carry(pablo_blk_MatchStar(m0, lex.Digit, carryQ.get_carry_in(6), m0));
2109        output.tem = m9;
2110        temp = m0;
2111        m11 = m0;
2112        carryQ.cq[7] = carryout2carry(pablo_blk_Advance(simd_and(m11, lex.E_and_e), carryQ.get_carry_in(7), m11));
2113        m13 = m11;
2114        carryQ.cq[8] = carryout2carry(pablo_blk_Advance(simd_and(m13, lex.P_H_sign), carryQ.get_carry_in(8), m13));
2115        m11 = simd_or(m11, m13);
2116        m16 = m11;
2117        carryQ.cq[9] = carryout2carry(pablo_blk_Advance(simd_and(m16, lex.Digit), carryQ.get_carry_in(9), m16));
2118        m11 = m16;
2119        carryQ.cq[10] = carryout2carry(pablo_blk_MatchStar(m11, lex.Digit, carryQ.get_carry_in(10), m11));
2120        m0 = simd_or(m0, m11);
2121        carryQ.cq[11] = carryout2carry(pablo_blk_Advance(simd_and(m0, lex.content_end), carryQ.get_carry_in(11), m0));
2122        output.matches = simd<1>::constant<0>();
2123        all_matches = m0;
2124        output.matches = temp;
2125  }
2126  CarryArray<12, 0> carryQ;
2127  };
2128
2129  struct Add_scope_streams {
2130  Add_scope_streams() { 
2131 }
2132  IDISA_INLINE void do_block(Lex & lex, Scope1 & scope1) {
2133                BitBlock v, w, v1, w1;
2134
2135
2136
2137
2138        v = simd_or(lex.LAngle, lex.Hyphen);
2139        w = simd_or(lex.Hyphen, lex.QMark);
2140        carryQ.cq[0] = carryout2carry(pablo_blk_Advance(v, carryQ.get_carry_in(0), v1));
2141        carryQ.cq[1] = carryout2carry(pablo_blk_Advance(w, carryQ.get_carry_in(1), w1));
2142        scope1.LAngle = simd_andc(v1, w1);
2143        scope1.Hyphen = simd_and(v1, w1);
2144        scope1.QMark = simd_andc(w1, v1);
2145        scope1.RefStart = simd<1>::constant<0>();
2146        carryQ.CarryQ_Adjust(2);
2147  }
2148  IDISA_INLINE void clear() { 
2149 }
2150  void do_final_block(Lex & lex, Scope1 & scope1, BitBlock EOF_mask) {
2151                BitBlock v, w, v1, w1;
2152
2153
2154
2155
2156        v = simd_or(lex.LAngle, lex.Hyphen);
2157        w = simd_or(lex.Hyphen, lex.QMark);
2158        carryQ.cq[0] = carryout2carry(pablo_blk_Advance(v, carryQ.get_carry_in(0), v1));
2159        carryQ.cq[1] = carryout2carry(pablo_blk_Advance(w, carryQ.get_carry_in(1), w1));
2160        scope1.LAngle = simd_andc(v1, w1);
2161        scope1.Hyphen = simd_and(v1, w1);
2162        scope1.QMark = simd_andc(w1, v1);
2163        scope1.RefStart = simd<1>::constant<0>();
2164  }
2165  CarryArray<2, 0> carryQ;
2166  };
2167
2168
2169
2170#include <simd-lib/transpose.hpp>
2171#include <post_process.hpp>
2172
2173static inline int ScanBackwardPos(BitBlock * block, int pos)
2174{
2175//      cout << "pos " << pos << endl;
2176    BitBlock s = block[0];
2177    if (bitblock::any(block[0])){
2178//      print_register("zero",block[0]);
2179//      print_register("t",simd_not(simd<128>::sll(simd<1>::constant<1>(), convert(pos))) );
2180        }
2181    BitBlock temp = simd_and( s, simd_not(simd<128>::sll(simd<1>::constant<1>(), convert(pos))) );
2182//      print_register("zero",simd_not(simd<128>::sll(simd<1>::constant<1>());
2183//              print_register("temp",temp);
2184    if (bitblock::any(temp))
2185    {
2186        // sizeof (BitBlock)*8 - cbzl( s & ~(~0 << pos)) - 1;
2187//      cout << "block_size" << BLOCK_SIZE << endl;
2188        return BLOCK_SIZE - count_reverse_zeroes(temp) - 1;
2189    }
2190    else
2191    {
2192        //handle boundary case
2193        return previous_block_last_elem_start - 1;
2194    }
2195}
2196
2197static inline int StreamScan(ScanBlock * stream, int blk_count, int ProcessPos(int)) {
2198        int blk;
2199        int block_pos = 0;
2200        for (blk = 0; blk < blk_count; blk++) {
2201                ScanBlock s = stream[blk];
2202                while(s) {
2203                        int code = (ProcessPos(cfzl(s) + block_pos));
2204                        if (code) return code;
2205                        s = s & (s-1);  // clear rightmost bit.
2206                }
2207                block_pos += 8 * sizeof(ScanBlock);
2208        }
2209        return 0;
2210}
2211
2212static inline int compute_hash_value2(char *str,int lgth){
2213        int hash = 5381;
2214    int c;
2215//      while (c = *str++){
2216        for (int i = 0;i<lgth;i++){
2217                c=*str++; 
2218        hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
2219    }
2220
2221    return hash;
2222}
2223
2224static inline int compute_hash_value (int lgth, int start)
2225{
2226    unsigned int offset_bit = start + 128;
2227    uint64_t stream = *((uint64_t*)(((uint32_t*)hashvalues)+(offset_bit>>5)));
2228    return stream >> (offset_bit & 0x1F) & ~(~0 << lgth);
2229}
2230
2231static inline void print_basis_bits(Basis_bits & basis_bits){
2232        print_register("bit0:",basis_bits.bit_0);
2233        print_register("bit1:",basis_bits.bit_1);
2234        print_register("bit2:",basis_bits.bit_2);
2235        print_register("bit3:",basis_bits.bit_3);
2236        print_register("bit4:",basis_bits.bit_4);
2237        print_register("bit5:",basis_bits.bit_5);
2238        print_register("bit6:",basis_bits.bit_6);
2239        print_register("bit7:",basis_bits.bit_7);                                       
2240}
2241/*
2242template <int L>
2243static inline int ElemEnd_grouping(int pos) {
2244    int end = block_base + pos;
2245    int start = end - L;
2246    int hashvalue = compute_hash_value(L, start - block_base);
2247    int gid = pbgs_symbol_table.Lookup_or_Insert_Name<L>(source + start, hashvalue);
2248    gids.push_back(gid);
2249#if DEBUG
2250    char* symbol = new char[L+1];
2251    strncpy ( symbol, source + start, L );
2252    symbol[L] ='\0';
2253    printf ("%s | start: %i[%i] | end: %i[%i] | gid: %i | hashvalue: %i | symbol: %s\n", __FUNCTION__, start, start-buffer_base, end, end-buffer_base, gid, hashvalue, symbol );
2254    delete symbol; symbol = 0;
2255#endif
2256    return gid;
2257}
2258
2259template<>
2260inline int ElemEnd_grouping<17>(int pos) {
2261    int end = block_base + pos;
2262    int start = ScanBackwardPos (&elem_starts, pos) + block_base;
2263    int lgth = end - start;
2264    int hashvalue = compute_hash_value(lgth, start - block_base);
2265    int gid = 0;
2266
2267//    if (lgth < 32)
2268//    {
2269//      gid = pbgs_symbol_table.Lookup_or_Insert_Name_32(source + start, hashvalue, lgth);
2270//    }
2271//    else
2272    {
2273        gid = pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
2274    }
2275    gids.push_back(gid);
2276#if DEBUG
2277    char* symbol = new char[lgth+1];
2278    strncpy ( symbol, source + start, lgth );
2279    symbol[lgth] ='\0';
2280    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);
2281#endif
2282    return gid;
2283}
2284*/
2285
2286static inline char ElemEnd_grouping(char *source,int block_base,int pos) {
2287    int end = block_base + pos;
2288    int start = ScanBackwardPos(&elem_starts, pos) + block_base;
2289    ///////////////////////
2290    //start could be negitive
2291    //the element name falls in two buffers
2292    ///////////////////////
2293    char *name = source + start;
2294    char name_buffer[50];
2295   
2296    if (start<0){
2297#ifdef DEBUG
2298            fprintf(gid_writein,"name_buffer %s\n",element_name_buffer);
2299#endif
2300        memmove (&name_buffer[0],&element_name_buffer[ELEMENT_BUFFER_SIZE+start],-start);       
2301        memmove (&name_buffer[-start],&source[0],50+start);
2302        name = name_buffer;
2303        //fprintf (gid_writein,"name_buffer %s",name);
2304#ifdef DEBUG
2305        fprintf(gid_writein,"name_buffer %s\n",name);
2306#endif
2307    }
2308//    cout << end << "  " << start << endl;
2309    int lgth = end - start;
2310//    int hashvalue = compute_hash_value(lgth,start-block_base);
2311        int hashvalue = compute_hash_value2(name,lgth);
2312    char gid = 0;
2313
2314
2315//    if (lgth < 32)
2316//    {
2317//      gid = pbgs_symbol_table.Lookup_or_Insert_Name_32(source + start, hashvalue, lgth);
2318//    }
2319//    else
2320
2321        switch (lgth)
2322    {
2323    case 1:
2324        gid = pbgs_symbol_table.Lookup_or_Insert_Name<1>(name, hashvalue);
2325        break;
2326    case 2:
2327        gid = pbgs_symbol_table.Lookup_or_Insert_Name<2>(name, hashvalue);
2328        break;
2329    case 3:
2330        gid = pbgs_symbol_table.Lookup_or_Insert_Name<3>(name, hashvalue);
2331        break;
2332    case 4:
2333        gid = pbgs_symbol_table.Lookup_or_Insert_Name<4>(name, hashvalue);
2334        break;
2335    case 5:
2336        gid = pbgs_symbol_table.Lookup_or_Insert_Name<5>(name, hashvalue);
2337        break;
2338    case 6:
2339        gid = pbgs_symbol_table.Lookup_or_Insert_Name<6>(name, hashvalue);
2340        break;
2341    case 7:
2342        gid = pbgs_symbol_table.Lookup_or_Insert_Name<7>(name, hashvalue);
2343        break;
2344    case 8:
2345        gid = pbgs_symbol_table.Lookup_or_Insert_Name<8>(name, hashvalue);
2346        break;
2347    case 9:
2348        gid = pbgs_symbol_table.Lookup_or_Insert_Name<9>(name, hashvalue);
2349        break;
2350    case 10:
2351        gid = pbgs_symbol_table.Lookup_or_Insert_Name<10>(name, hashvalue);
2352        break;
2353    case 11:
2354        gid = pbgs_symbol_table.Lookup_or_Insert_Name<11>(name, hashvalue);
2355        break;
2356    case 12:
2357        gid = pbgs_symbol_table.Lookup_or_Insert_Name<12>(name, hashvalue);
2358        break;
2359    case 13:
2360        gid = pbgs_symbol_table.Lookup_or_Insert_Name<13>(name, hashvalue);
2361        break;
2362    case 14:
2363        gid = pbgs_symbol_table.Lookup_or_Insert_Name<14>(name, hashvalue);
2364        break;
2365    case 15:
2366        gid = pbgs_symbol_table.Lookup_or_Insert_Name<15>(name, hashvalue);
2367        break;
2368    case 16:
2369        gid = pbgs_symbol_table.Lookup_or_Insert_Name<16>(name, hashvalue);
2370        break;
2371    default:
2372        gid = pbgs_symbol_table.Lookup_or_Insert_Name(name, hashvalue, lgth);
2373        break;
2374    }
2375/*
2376    {
2377        gid = (char)pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
2378    }
2379*/
2380    gids.push_back(gid);
2381#ifdef DEBUG
2382    char* symbol = new char[lgth+1];
2383    strncpy ( symbol, source + start, lgth );
2384    symbol[lgth] ='\0';
2385//    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);
2386    fprintf (gid_writein,"%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);
2387#endif
2388    return gid;
2389}
2390
2391static inline int print_source(char* source, int lgth ,int seg){
2392        char ret[128];
2393        int j;
2394        for (int i=0;i<seg;i++){
2395                for(j=0;j<lgth;j++){
2396                        if(source[i*lgth+j]!='\n')
2397                                ret[j] = source[i*lgth + j];
2398                        else
2399                                ret[j] = ' ';
2400                }
2401                ret[j] = '\0';
2402//              cout << ret << endl;
2403        }
2404        return 0;
2405}
2406
2407Validate_content_5 validate_content_5;
2408
2409static inline void validate_data_type(int char_aval, int gid_index){
2410        struct Lex lex;
2411        struct Output output;
2412        Classify_bytes_Validate_utf8 classify_bytes_Validate_utf8;
2413        U8 u8;
2414        Basis_bits temp_basis_bits;
2415//      Validate_content_5 validate_content_5;
2416       
2417        if(char_aval == BLOCK_SIZE){
2418                s2p_do_block((BytePack*)(&content_buffer), temp_basis_bits);
2419#ifdef DEBUG
2420                print_basis_bits(temp_basis_bits);
2421#endif
2422                classify_bytes_Validate_utf8.do_block(temp_basis_bits,lex,u8);
2423#ifdef  DEBUG
2424                cout << content_buffer << endl;
2425               
2426                print_register("digit:",lex.Digit);
2427                print_register("dot:",lex.Dot);
2428                print_register("namescan:",lex.NameScan);
2429                print_register("P_N:",lex.P_H_sign);
2430                print_register("content_end:",lex.content_end);
2431#endif
2432                validate_content_5.do_block(lex,output);
2433#ifdef DEBUG
2434                print_register("output:",output.matches);
2435                print_register("output.tem:",output.tem);
2436#endif
2437        }else{
2438                int remaining = BLOCK_SIZE -char_aval;
2439                BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
2440                s2p_do_final_block((BytePack*)(&content_buffer), temp_basis_bits,EOF_mask);
2441                classify_bytes_Validate_utf8.do_final_block(temp_basis_bits,lex,u8,EOF_mask);
2442                validate_content_5.do_final_block(lex,output,EOF_mask);
2443        }
2444}
2445
2446
2447//template <int L>
2448static inline int StreamScanLengthGrouping(char *source,int block_base,ScanBlock * stream, ScanBlock * stream2, int blk_count,ScanBlock * stream3,ScanBlock * stream4) {
2449    int blk;
2450    int block_pos = 0;
2451//    cout << "cfzl():" << cfzl() << endl;
2452//      long test = 6;
2453//      test = (test & (test - 1));
2454//      cout << "test" << endl;
2455    for (blk = 0; blk < blk_count; blk++) {
2456//      cout << "blk:" << blk << endl;
2457   
2458                ScanBlock s = stream[blk];
2459                ScanBlock s2 = stream2[blk];
2460                ScanBlock s3 = stream3[blk];
2461                ScanBlock s4 = stream4[blk];
2462                int end_content;
2463                int start_content;
2464                int content_lgth;
2465                int content_aval = CONTENT_BUFFER_SIZE - content_buffer_pos;
2466               
2467//              cout << "block_pos " << block_pos <<endl;
2468//#ifdef DATATYPE
2469if(Symbol && Datatype)  {
2470                if (content_start_carry == 1 && gid == CONTENT_INDEX){
2471//                      cout << "****" << endl;
2472                        start_content = cfzl(s3) + block_pos;
2473                                        if (cfzl(s3) != 8*sizeof(ScanBlock)){
2474                                                content_start_carry = 0;
2475                                        }
2476                                       
2477                                        end_content = cfzl(s4) + block_pos;
2478                                        while(end_content < start_content){
2479                                                s4 = s4 & (s4-1);
2480                                                end_content = cfzl(s4) + block_pos;
2481                                        }
2482        //                      cout << "cfzl" << cfzl(s4) << " " <<sizeof(ScanBlock) <<endl;
2483                                        if(cfzl(s4)==8*sizeof(ScanBlock)){
2484                                                content_carry = 1;
2485        //                              cout << "end_of_block" << endl;
2486                                        }
2487                                        content_lgth = end_content - start_content;
2488//                                      cout << end_content << " " << start_content <<endl;
2489//                                      cout << "lgth: " << content_lgth << endl;
2490                                        content_aval = CONTENT_BUFFER_SIZE - content_buffer_pos;
2491                                        int full_content = 0;
2492                                        int buffer_full = 0;
2493                                        if(content_carry != 1 && gid == CONTENT_INDEX){
2494                                                if(content_aval > content_lgth-2 && content_lgth > 2 && gid == CONTENT_INDEX){
2495                                                        memmove(&content_buffer[content_buffer_pos],&source[start_content+block_base+1],content_lgth-2);
2496                                                        char temp = '#';
2497                                                        content_buffer_pos += content_lgth-2;
2498                                                        memmove(&content_buffer[content_buffer_pos],&temp,1);
2499                                                        content_buffer_pos ++;
2500//                                                      cout << "@@" <<endl;
2501//                                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_lgth-2 << endl;
2502                                                }else if(gid == CONTENT_INDEX){
2503                                                        memmove(&content_buffer[content_buffer_pos],&source[start_content+block_base+1],content_aval);
2504                                                        full_content = 1;
2505                                               
2506                                                        content_buffer_pos += content_aval;
2507                                                        memmove(&content_lookahead_buffer[0],&source[start_content+block_base+1+content_aval],content_lgth-2-content_aval);
2508//                                                      cout << "@@@" <<endl;
2509//                                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;       
2510                                                        content_buffer_pos = content_lgth-2-content_aval;
2511                                                        buffer_full = 1;
2512                                                }
2513                                        }else if(gid == CONTENT_INDEX){
2514                                                if(content_aval > content_lgth-1 && content_lgth > 1 && gid == CONTENT_INDEX){
2515//                                                      cout << "@" << endl;
2516//                                              cout << content_aval << "   " << content_lgth << endl;
2517                                                memmove(&content_buffer[content_buffer_pos],&source[start_content+block_base+1],content_lgth-1);
2518//                                              printf("%.*s\n",content_lgth-1,&content_buffer[content_buffer_pos]);
2519                                                        content_buffer_pos += content_lgth-1;
2520//                                                      full_content = 1;       
2521                                                }else if(content_aval < content_lgth-1 && gid == CONTENT_INDEX){
2522//                                                      cout << "@@@@" << endl;
2523//                                                      cout << content_aval << "   " << content_lgth << endl;
2524                                                        memmove(&content_buffer[content_buffer_pos],&source[start_content+block_base+1],content_aval);
2525                                               
2526                                                        content_buffer_pos += content_aval;
2527                                                        memmove(&content_lookahead_buffer[0],&source[start_content+block_base+1+content_aval],content_lgth-1-content_aval);
2528        //                                              full_content = 1;
2529                                                        content_buffer_pos = content_lgth-1-content_aval;
2530                                                        buffer_full = 1;
2531                                                }
2532                                        }
2533                                        if (buffer_full == 1){
2534        //                              cout << "buffer_full" << endl;
2535        //                                  content_buffer[CONTENT_BUFFER_SIZE-1] = '\0';
2536        //                              cout << content_buffer << endl << endl;
2537if(!Data_gather)
2538                                                validate_data_type(CONTENT_BUFFER_SIZE,5);
2539                                                memmove(&content_buffer[0],&content_lookahead_buffer[0],content_buffer_pos);
2540                                                if (full_content == 1){
2541                                                        char temp = '#';
2542                                                        memmove(&content_buffer[content_buffer_pos],&temp,1);
2543                                                        content_buffer_pos ++;
2544                                                        full_content = 0;
2545                                                }
2546                                                buffer_full = 0;
2547                                        }
2548                }else if (content_carry == 1 && gid == CONTENT_INDEX){
2549                end_content = cfzl(s4) + block_pos;
2550                start_content = block_pos-1;
2551                content_lgth = end_content-block_pos;
2552                content_aval = CONTENT_BUFFER_SIZE - content_buffer_pos;
2553                if (cfzl(s4) != 8*sizeof(ScanBlock)){
2554                        content_carry = 0;
2555                        s4 = s4 & (s4-1);
2556                }
2557                int buffer_full = 0;
2558                if (content_carry !=1){
2559                                if(content_aval > content_lgth-1 && content_lgth > 1){
2560//                                      cout << "##" << endl;
2561        //                      cout << "lgth " << content_lgth << endl;
2562                                        memmove(&content_buffer[content_buffer_pos],&source[block_pos+block_base],content_lgth-1);
2563//                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;
2564//                                      cout << "content_lgth " << content_lgth <<endl;
2565//                                      printf("%.*s\n",content_lgth-1+content_buffer_pos,content_buffer);
2566                                        content_buffer_pos += content_lgth-1;
2567                                        char temp = '#';
2568                                        memmove(&content_buffer[content_buffer_pos],&temp,1);
2569                                        content_buffer_pos ++;
2570        //                      content_buffer[content_buffer_pos] = '\0';
2571        //                      cout << "^^^" << endl;
2572        //                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_lgth-1 << endl;
2573        //                      cout << content_buffer << endl;
2574                                }else if (content_lgth == 0){
2575                                        content_buffer[content_buffer_pos-1] = '#';
2576                                }else if (content_aval > 0 && content_lgth == 1){
2577//                                      cout << "###" << endl;
2578                                        content_buffer[content_buffer_pos] = '#';
2579                                        content_buffer_pos++;
2580                                        if(content_buffer_pos == CONTENT_BUFFER_SIZE){
2581if(!Data_gather)
2582                                                validate_data_type(CONTENT_BUFFER_SIZE,5);
2583                                                content_buffer_pos = 0;
2584                                        }
2585                                }else if (content_aval <= content_lgth-1){
2586//                                      cout << "@@@@@@@@@@@@@@@@@@" << endl;
2587                                        memmove(&content_buffer[content_buffer_pos],&source[block_pos+block_base],content_aval);
2588                                        memmove(&content_lookahead_buffer[0],&source[block_pos+block_base+content_aval],content_lgth-1-content_aval);
2589//                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;
2590//                                      cout << "content_lgth " << content_lgth <<endl;
2591//                                      printf("%.*s\n",content_aval,&content_buffer[content_buffer_pos]);
2592                                        content_buffer_pos = content_lgth-1-content_aval;
2593        //                              content_buffer[CONTENT_BUFFER_SIZE-1] = '\0';
2594        //                              cout << content_buffer << endl << endl;
2595if(!Data_gather)
2596                                        validate_data_type(CONTENT_BUFFER_SIZE,5);
2597                                        memmove(&content_buffer[0],&content_lookahead_buffer[0],content_buffer_pos);
2598                                        if (content_lgth-1 < CONTENT_BUFFER_SIZE){
2599                                                content_buffer[content_buffer_pos] = '#';
2600                                                content_buffer_pos ++;
2601                                        }
2602                                }
2603                }else if(gid == CONTENT_INDEX){
2604                        if(content_aval > content_lgth){
2605//                                      cout << "##*" << endl;
2606//                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;
2607//                                      cout << "content_lgth " << content_lgth <<endl;
2608                                        memmove(&content_buffer[content_buffer_pos],&source[block_pos+block_base],content_lgth);
2609//                                      printf("%.*s\n",content_lgth+content_buffer_pos,content_buffer);
2610                                        content_buffer_pos += content_lgth;
2611                                }else if (content_aval <= content_lgth && gid == CONTENT_INDEX){
2612//                                      cout << "@@@@@@@@@@@@@@@@@@*" << endl;
2613                                        memmove(&content_buffer[content_buffer_pos],&source[block_pos+block_base],content_aval);
2614                                        memmove(&content_lookahead_buffer[0],&source[block_pos+block_base+content_aval],content_lgth-content_aval);
2615//                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;
2616//                                      cout << "content_lgth " << content_lgth <<endl;
2617//                                      printf("%.*s\n",content_aval,&content_buffer[content_buffer_pos]);
2618                                        content_buffer_pos = content_lgth-content_aval;
2619if(!Data_gather)
2620                                        validate_data_type(CONTENT_BUFFER_SIZE,5);
2621                                        memmove(&content_buffer[0],&content_lookahead_buffer[0],content_buffer_pos);
2622                                }                       
2623                }
2624            }
2625}
2626//#endif
2627//              print_source(&source[block_base],sizeof(ScanBlock)*8,2);
2628//              print_register("start_content:",((BitBlock*)stream3)[0]);
2629//              print_register("end_content:",((BitBlock*)stream4)[0]);
2630//              cout << s << "  " << s2 << endl;
2631//              print_register("s:",((BitBlock*)stream)[0]);
2632                while(s | s2) {
2633//                      cout << "cfzl(s):" << cfzl(s)<<endl;
2634                    int end_pos = cfzl(s) + block_pos;
2635//                  cout << "s2 " << s2 << endl;
2636                    int end_tag = cfzl(s2) + block_pos;
2637//              cout << "cfzl(s):" << cfzl(s)<<endl;
2638//              cout << "cfzl(s2):" << cfzl(s2)<<endl;
2639//                      cout << (end_tag < end_pos && s2 != 0)<< "||" <<(s == 0 && s2 != 0)  << endl;
2640                        if ((end_tag < end_pos && s2 != 0) | (s == 0 && s2 != 0)){
2641//                      cout << "here" << endl;
2642//                      cout << "closing tag" << endl;
2643//                      cout << "endtag:" << end_tag << " " << end_pos<<endl;
2644//                      cout << "1"<< endl;
2645//                      cout << elem_vec_stack.size()<<endl;
2646//                      cout << "2" << endl;
2647//                      cout << elem_vec_stack.top()<<endl;
2648if(Content_gather && Content_model){
2649                                if(!(gid_vec[current_depth].empty())){
2650//                                      if(gid_vec.back() != 0){
2651                                                gid_vec[current_depth].push_back(0);
2652                                                if(current_depth !=0){
2653                                                        current_depth = pre_index.back();
2654                                                        pre_index.pop_back();
2655#ifdef DEBUG
2656                                                        fprintf (gid_writein,"%d\n",current_depth);
2657#endif
2658                                                        gid_vec[current_depth].push_back(0);
2659                                                }
2660//                                      }
2661                                }
2662}
2663//                              cout << "before" << s2 << endl;
2664                                s2 = s2 & (s2 - 1);
2665//                              cout << "after" << s2 << endl;
2666//                              cout << "s2 = " << s2 << endl;
2667                }else{
2668//                      cout << " end_pos == " << end_pos<<endl;
2669//                      cout << " end_tag_pos == " << end_tag << endl;
2670                        gid = ElemEnd_grouping(source,block_base,end_pos);
2671//#ifdef DATATYPE
2672if(Symbol && Datatype){
2673//                      printf("%d\n",int(gid));
2674                        if (gid == CONTENT_INDEX){
2675//                              cout << "source : ";
2676//                              printf("%.*s\n",sizeof(ScanBlock)*8,&source[block_base]);
2677                                        start_content = cfzl(s3) + block_pos;
2678                                        while(start_content < end_pos){
2679                                                s3 = s3 & (s3-1);
2680                                                start_content = cfzl(s3) + block_pos;
2681                                        }
2682                                        if (cfzl(s3) == 8*sizeof(ScanBlock)){
2683                                                content_start_carry = 1;
2684                                        }
2685                                        if (content_start_carry != 1){
2686                //                      cout << "end_pos " << end_pos <<endl;
2687                //                      char temp[20];
2688                //                      memmove(temp,&source[end_pos+block_base],20);
2689                //                      cout << "source: " << temp << endl;
2690                                                //cout << "start_content " << start_content << endl;
2691                                       
2692                                                end_content = cfzl(s4) + block_pos;
2693                                                while(end_content < start_content){
2694                                                        s4 = s4 & (s4-1);
2695                                                        end_content = cfzl(s4) + block_pos;
2696                                                }
2697                //                      cout << "cfzl" << cfzl(s4) << " " <<sizeof(ScanBlock) <<endl;
2698                                                if(cfzl(s4)==8*sizeof(ScanBlock)){
2699                                                        content_carry = 1;
2700                //                              cout << "end_of_block" << endl;
2701                                                }
2702                                                content_lgth = end_content - start_content;
2703//                                              cout << end_content << " " << start_content <<endl;
2704//                                              cout << "lgth: " << content_lgth << endl;
2705                                                content_aval = CONTENT_BUFFER_SIZE - content_buffer_pos;
2706                                                int full_content = 0;
2707                                                int buffer_full = 0;
2708                                                if(content_carry != 1 && gid == CONTENT_INDEX){
2709                                                        if(content_aval > content_lgth-2 && content_lgth > 2 && gid == CONTENT_INDEX){
2710                                                                memmove(&content_buffer[content_buffer_pos],&source[start_content+block_base+1],content_lgth-2);
2711                                                                char temp = '#';
2712                                                                content_buffer_pos += content_lgth-2;
2713                                                                memmove(&content_buffer[content_buffer_pos],&temp,1);
2714                                                                content_buffer_pos ++;
2715                //                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << endl;
2716//                                                              cout << "@@" <<endl;
2717//                                                              cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_lgth-2 << endl;
2718                                                        }else if(gid == CONTENT_INDEX){
2719                                                                memmove(&content_buffer[content_buffer_pos],&source[start_content+block_base+1],content_aval);
2720                                                                full_content = 1;
2721                                               
2722                                                                content_buffer_pos += content_aval;
2723                                                                memmove(&content_lookahead_buffer[0],&source[start_content+block_base+1+content_aval],content_lgth-2-content_aval);
2724//                                                              cout << "@@@" <<endl;
2725//                                                              cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;       
2726                                                                content_buffer_pos = content_lgth-2-content_aval;
2727                                                                buffer_full = 1;
2728                                                        }
2729                                                }else if(gid == CONTENT_INDEX){
2730                                                        if(content_aval > content_lgth-1 && content_lgth > 1 && gid == CONTENT_INDEX){
2731//                                                              cout << "@" << endl;
2732//                                                              cout << content_aval << "   " << content_lgth << endl;
2733                                                                memmove(&content_buffer[content_buffer_pos],&source[start_content+block_base+1],content_lgth-1);
2734//                                                              printf("%.*s\n",content_lgth-1+content_buffer_pos,content_buffer);
2735                                                                content_buffer_pos += content_lgth-1;
2736        //                                                      full_content = 1;
2737                //                                      cout << content_carry << endl;
2738                //                                      cout << content_buffer << endl << endl;
2739                //                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE<< "            "<< content_lgth-1 << endl;             
2740                                                        }else if(content_aval < content_lgth-1 && gid == CONTENT_INDEX){
2741//                                                              cout << "@@@@" << endl;
2742//                                                              cout << content_aval << "   " << content_lgth << endl;
2743                                                                memmove(&content_buffer[content_buffer_pos],&source[start_content+block_base+1],content_aval);
2744                                               
2745                                                                content_buffer_pos += content_aval;
2746                                                                memmove(&content_lookahead_buffer[0],&source[start_content+block_base+1+content_aval],content_lgth-1-content_aval);
2747                //                                              full_content = 1;
2748                //                                              cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;       
2749                                                                content_buffer_pos = content_lgth-1-content_aval;
2750                                                                buffer_full = 1;
2751                                                        }
2752                                                }
2753                                                if (buffer_full == 1){
2754                //                              cout << "buffer_full" << endl;
2755                //                                  content_buffer[CONTENT_BUFFER_SIZE-1] = '\0';
2756                //                              cout << content_buffer << endl << endl;
2757                                                        validate_data_type(CONTENT_BUFFER_SIZE,5);
2758                                                        memmove(&content_buffer[0],&content_lookahead_buffer[0],content_buffer_pos);
2759                                                        if (full_content == 1){
2760                                                                char temp = '#';
2761                                                                memmove(&content_buffer[content_buffer_pos],&temp,1);
2762                                                                content_buffer_pos ++;
2763                                                                full_content = 0;
2764                                                        }
2765                                                        buffer_full = 0;
2766                                                }
2767                                        }
2768                        }
2769}
2770//#endif                       
2771//                      content_buffer[content_buffer_pos] = '\0';
2772//                      cout << content_buffer << endl;
2773                        if (s!=0){
2774                                s = s & (s-1);  // clear rightmost bit.
2775                        }
2776                        //else{
2777                        //      s2 = s2 & (s2 - 1);
2778                        //}
2779if(Content_gather && Content_model){
2780                                if (gid != 0){
2781                                        gid_vec[current_depth].push_back(gid);
2782#ifdef DEBUG
2783                                        fprintf (gid_writein,"%d\n",current_depth);
2784#endif
2785                                        pre_index.push_back(current_depth);
2786                                        current_depth = (int)gid;
2787                                        gid_vec[current_depth].push_back(gid);
2788#ifdef DEBUG
2789                                        fprintf (gid_writein,"%d\n",current_depth);                     
2790#endif
2791                                }
2792}
2793                }       
2794                }
2795                block_pos += 8 * sizeof(ScanBlock);
2796//              print_gid_vec();
2797    }
2798    return 0;
2799}
2800
2801void print_gid_vec(){
2802        for (int j = 0; j < MAX_DEPTH; j++){
2803                if(gid_vec[j].empty()){
2804                        return;
2805                }
2806                for (int i = 0; i < gid_vec[j].size(); i++){
2807                        cout << j << ":" << endl;
2808                        cout << (int)gid_vec[j][i] << " ";
2809                }
2810        }
2811        cout << endl;
2812/*     
2813        int i = 1;
2814        int lst[256] = {0};
2815        cout << elem_vec_map.size() << " vectors" << endl;
2816        for (int i = 0;i < gids.size(); i++){
2817                if (lst[gids[i]] == 0){
2818                        cout << "gid: " << gids[i] << endl;
2819                        lst[gids[i]] = 1;
2820                        vector<char> *tmp = elem_vec_map[gids[i]];
2821                        cout << "vector size:"<< (*tmp).size()<<endl;
2822                        if ((*tmp).size()!=0){
2823                                cout << "elements: ";
2824                                for (int j = 0; j < (*tmp).size();j++){
2825                                        cout << (int)(*tmp)[j] << " ";
2826                                }
2827                                cout << endl;
2828                        }
2829                        cout << endl;
2830                }
2831        }
2832*/
2833}
2834/*
2835static inline int NameStrt_check(int pos) {
2836        int block_pos = block_base + pos;
2837        if(XML_10_UTF8_NameStrt_bytes((unsigned char*)&source[block_pos]) == 0){
2838              ReportError("name start error", pos);
2839              exit(-1);
2840        }
2841        return 0;
2842}
2843
2844static inline int Name_check(int pos) {
2845        int block_pos = block_base + pos;
2846        if(XML_10_UTF8_NameChar_bytes((unsigned char*)&source[block_pos]) == 0){
2847              ReportError("name error", pos);
2848              exit(-1);
2849        }
2850        return 0;
2851}
2852
2853static inline int PIName_check(int pos) {
2854        int block_pos = block_base + pos;
2855        int file_pos = block_pos+buffer_base;
2856        printf ("%s:%i\n",__FUNCTION__,pos);
2857        if (at_XxMmLll<ASCII>((unsigned char*)&source[block_pos]) && (source[block_pos+3]=='?' || source[block_pos+3]<= ' ')) {
2858              // "<?xml" legal at start of file.
2859              if ((file_pos == 2) && at_XmlDecl_start<ASCII>((unsigned char*)&source[0])) return 0;
2860              ReportError("[Xx][Mm][Ll] illegal as PI name", pos);
2861              exit(-1);
2862        }
2863        return 0;
2864}
2865
2866static inline int CD_check(int pos) {
2867        int block_pos = block_base + pos;
2868        if (!at_CDATA1<ASCII>((unsigned char*)&source[block_pos])){
2869              ReportError("CDATA error", pos);
2870              exit(-1);
2871        }
2872        return 0;
2873}
2874
2875static inline int GenRef_check(int pos) {
2876        int block_pos = block_base + pos;
2877        unsigned char* s = (unsigned char*)&source[block_pos];
2878        if (!(at_Ref_gt<ASCII>(s)||at_Ref_lt<ASCII>(s)||at_Ref_amp<ASCII>(s)||at_Ref_quot<ASCII>(s)||at_Ref_apos<ASCII>(s))){
2879                        cout << pos << endl;
2880              ReportError("Undefined reference", pos);
2881              exit(-1);
2882        }
2883        return 0;
2884}
2885
2886static inline int HexRef_check(int pos) {
2887        int block_pos = block_base + pos;
2888        unsigned char* s = (unsigned char*)&source[block_pos];
2889        int ch_val = 0;
2890        while(at_HexDigit<ASCII>(s)){
2891          ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
2892          if (ch_val> 0x10FFFF ){
2893            ReportError("Illegal character reference", pos);
2894            exit(-1);
2895          }
2896          s++;
2897        }
2898        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
2899          ReportError("Illegal character reference", pos);
2900          exit(-1);
2901        }
2902        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
2903          ReportError("Illegal XML 1.0 character reference", pos);
2904          exit(-1);
2905        }
2906        return 0;
2907}
2908
2909static inline int DecRef_check(int pos) {
2910        int block_pos = block_base + pos;
2911        unsigned char* s = (unsigned char*)&source[block_pos];
2912        int ch_val = 0;
2913        while(at_HexDigit<ASCII>(s)){
2914          ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
2915          if (ch_val> 0x10FFFF ){
2916            ReportError("Illegal character reference", pos);
2917            exit(-1);
2918          }
2919          s++;
2920        }
2921        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
2922          ReportError("Illegal character reference", pos);
2923          exit(-1);
2924        }
2925        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
2926          ReportError("Illegal XML 1.0 character reference", pos);
2927          exit(-1);
2928        }
2929        return 0;
2930}
2931
2932static inline int AttRef_check(int pos) {
2933        int block_pos = block_base + pos;
2934        unsigned char* s = (unsigned char*)&source[block_pos];
2935        int ch_val = 0;
2936        if(s[0]=='#'){
2937          s++;
2938          if(s[0]=='x' || s[0]=='X'){
2939            s++;
2940            while(at_HexDigit<ASCII>(s)){
2941              ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
2942              s++;
2943            }
2944          }
2945          else{
2946            while(at_HexDigit<ASCII>(s)){
2947              ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
2948              s++;
2949            }
2950          }
2951          if (ch_val==60){
2952            ReportError("Attribute values contain '<' characters after reference expansion", pos);
2953            exit(-1);
2954          }
2955        }
2956        else if(at_Ref_lt<ASCII>(s)){
2957          ReportError("Attribute values contain '<' characters after reference expansion", pos);
2958          exit(-1);
2959        }
2960        return 0;
2961}
2962*/
2963
2964
2965
2966
2967/*
2968static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
2969  s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
2970        basis_bits.bit_0, basis_bits.bit_1, basis_bits.bit_2, basis_bits.bit_3, basis_bits.bit_4, basis_bits.bit_5, basis_bits.bit_6, basis_bits.bit_7);
2971}
2972
2973static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask) {
2974  s2p_do_block(U8, basis_bits);
2975  basis_bits.bit_0 = simd_and(basis_bits.bit_0, EOF_mask);
2976  basis_bits.bit_1 = simd_and(basis_bits.bit_1, EOF_mask);
2977  basis_bits.bit_2 = simd_and(basis_bits.bit_2, EOF_mask);
2978  basis_bits.bit_3 = simd_and(basis_bits.bit_3, EOF_mask);
2979  basis_bits.bit_4 = simd_and(basis_bits.bit_4, EOF_mask);
2980  basis_bits.bit_5 = simd_and(basis_bits.bit_5, EOF_mask);
2981  basis_bits.bit_6 = simd_and(basis_bits.bit_6, EOF_mask);
2982  basis_bits.bit_7 = simd_and(basis_bits.bit_7, EOF_mask);
2983}
2984*/
2985
2986static inline void print_elem_vec(vector<char>* vec, int size, int depth){
2987        cout << "vector " << depth << ":";
2988        for (int i = 0; i<size ; i++){
2989                cout << (int)(*vec)[i] <<" ";
2990        }
2991        cout << endl;
2992}
2993
2994static inline void vec_scan(BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> match_scanner,BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> f_vec_scanner,char* str,int index){
2995        int current_pos = 0;
2996        int next_pos = 0;
2997        int match_pos = 0;
2998//      cout << str <<" = " << index <<endl;
2999//      cout << "vec_scan" << endl;
3000        cout << f_vec_scanner.get_final_pos() << "&&" << endl;
3001        if(f_vec_scanner.has_next()){
3002                current_pos = f_vec_scanner.scan_to_next();
3003//              cout << current_pos << endl;
3004        }else{
3005                return;
3006        }
3007        if (match_scanner.has_next()){
3008                match_pos = match_scanner.scan_to_next();
3009        }else{
3010                printf("Mismatch found at pos of %s %d: %d.\n",str,index,current_pos);
3011                while(f_vec_scanner.has_next()){
3012                        current_pos = f_vec_scanner.scan_to_next();
3013                        printf("Mismatch found at pos of %s %d: %d.\n",str,index,current_pos);
3014                }
3015                return;
3016        }
3017        while(1){
3018                if(f_vec_scanner.has_next()){
3019                        next_pos = f_vec_scanner.scan_to_next();
3020                }else{
3021                        next_pos = -1;
3022                }
3023                if(next_pos > match_pos){
3024                        cout <<"##" << next_pos << "  " << match_pos << endl; 
3025                        current_pos = next_pos;
3026                        match_pos = match_scanner.scan_to_next();
3027                        continue;
3028                }else if(next_pos == -1){
3029                        break;
3030                }else if(next_pos < match_pos){
3031                        cout << next_pos << "  " << match_pos << endl; 
3032                        printf("Mismatch found at pos of %s %d: %d.\n",str,index,current_pos);
3033                        current_pos = next_pos;
3034                }
3035        }
3036/*     
3037        while(1){
3038                if(f_vec_scanner.has_next()){
3039                        next_pos = f_vec_scanner.scan_to_next();
3040                }else{
3041                        next_pos = -1;
3042                }
3043                if (match_pos > next_pos && next_pos != -1){
3044                        printf("Mismatch found at pos of %s %d: %d.\n",str,index,current_pos);
3045                }else if (next_pos == -1){
3046                        break;
3047                }else{
3048                        if(match_scanner.has_next()){
3049                                match_pos = match_scanner.scan_to_next();
3050                        }else{
3051                                printf("Mismatch found at pos of %s %d: %d.\n",str,index,next_pos);
3052                                while(f_vec_scanner.has_next()){
3053                                        current_pos = f_vec_scanner.scan_to_next();
3054                                        printf("Mismatch found at pos of %s %d: %d.\n",str,index,current_pos);
3055                                }
3056                                return;
3057                        }
3058                }
3059                current_pos = next_pos;
3060        }
3061*/
3062}
3063
3064static inline void validate_mul_block(){
3065        struct Elem elem;
3066        Validation_2 validation_2;
3067        Validation_4 validation_4;
3068        Validation_9 validation_9;
3069//      Validation_10 validation_10;
3070       
3071        struct Lex lex;
3072       
3073        struct Output output;
3074
3075        Classify_bytes classify_bytes;
3076        int j;
3077#ifdef DEBUG
3078        for(j=0;j<MAX_COUNT;j++){
3079        int lgth = gid_vec[j].size();
3080                if(!gid_vec[j].empty())
3081                        print_elem_vec(&(gid_vec[j]),lgth,j);
3082        }
3083#endif
3084        int lgth;
3085        for(j=0;j<MAX_COUNT;j++){
3086                lgth = gid_vec[j].size();
3087                int remaining = 0;
3088                Basis_bits temp_basis_bits;
3089                const int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
3090                int i = 0;
3091                int block_base;
3092                if(lgth != 0){ 
3093                        remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
3094                        for(i = 0;i < num_block; i++){
3095                                block_base = i*BLOCK_SIZE;
3096                               
3097                                s2p_do_block((BytePack*)(&(gid_vec[j][block_base])), temp_basis_bits);
3098                                classify_bytes.do_block(temp_basis_bits,lex);
3099                                switch (j){
3100                                        case 2:
3101                                        validation_2.do_block(lex,output);
3102#ifdef DEBUG                           
3103                                        print_register("cc2",lex.cc2);
3104                                        print_register("match_2",output.matches);
3105#endif
3106                                        break;
3107                                        case 4:
3108                                        validation_4.do_block(lex,output);
3109#ifdef DEBUG
3110                                        print_register("cc4",lex.cc4);
3111                                        print_register("match_4",output.matches);
3112#endif
3113                                        break;
3114                                        case 9:
3115                                        validation_9.do_block(lex,output);
3116#ifdef DEBUG
3117                                        print_register("cc9",lex.cc9);
3118                                        print_register("match_9",output.matches);
3119#endif
3120                                        break;
3121/*
3122                                        case 10:
3123                                        validation_10.do_block(lex,output);
3124#ifdef DEBUG
3125                                        print_register("cc10",lex.cc10);
3126                                        print_register("match_10",output.matches);
3127#endif
3128                                        break;
3129*/
3130                                }
3131                        }
3132                        if (remaining !=0){
3133                                block_base = i*BLOCK_SIZE;
3134                                //cout << "block_base " << block_base << endl;
3135                                BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
3136                                s2p_do_final_block((BytePack*)(&(gid_vec[j][block_base])), temp_basis_bits,EOF_mask);
3137                                classify_bytes.do_final_block(temp_basis_bits,lex,EOF_mask);
3138                                switch (j){
3139                                        case 2:
3140                                        validation_2.do_final_block(lex,output,EOF_mask);
3141#ifdef DEBUG
3142//                                      cout << remaining << endl;
3143                                        print_register("cc2",lex.cc2);
3144//                                      print_register("cc3",lex.cc3);
3145//                                      print_register("cc4",lex.cc4);
3146//                                      print_register("cc9",lex.cc9);
3147                                        print_register("match_2",output.matches);
3148#endif
3149                                        break;
3150                                        case 4:
3151                                        validation_4.do_final_block(lex,output,EOF_mask);
3152#ifdef DEBUG
3153                                        print_register("cc4",lex.cc4);
3154                                        print_register("match_4",output.matches);
3155#endif
3156                                        break;
3157                                        case 9:
3158                                        validation_9.do_final_block(lex,output,EOF_mask);
3159#ifdef DEBUG
3160                                        print_register("cc9",lex.cc9);
3161                                        print_register("match_9",output.matches);
3162#endif
3163                                        break;
3164/*
3165                                        case 10:
3166                                        validation_10.do_final_block(lex,output,EOF_mask);
3167#ifdef DEBUG
3168                                        print_register("cc10",lex.cc10);
3169                                        print_register("match_10",output.matches);
3170#endif
3171                                        break;
3172*/
3173                                }
3174                        }
3175                }
3176        }
3177}
3178
3179
3180
3181/*
3182
3183static inline void validate_mul_block(){
3184        struct Elem elem;
3185        Validation_2 validation_2;
3186//      Validation_2 validation_2;
3187        Validation_4 validation_4;
3188        Validation_9 validation_9;
3189//      Validation_4 validation_4;     
3190//      Validation_5 validation_5;
3191//      Validation_24 validation_24;
3192//      Validation_25 validation_25;
3193//      Validation_27 validation_27;
3194//      Validation_35 validation_35;
3195//      Validation_41 validation_41;
3196//      Validation_45 validation_45;
3197       
3198        struct Lex lex;
3199       
3200        struct Output output;
3201
3202        Classify_bytes classify_bytes;
3203        int j;
3204#ifdef DEBUG
3205        for(j=0;j<MAX_COUNT;j++){
3206        int lgth = gid_vec[j].size();
3207                if(!gid_vec[j].empty())
3208                        print_elem_vec(&(gid_vec[j]),lgth,j);
3209        }
3210#endif
3211        BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> match_scanner;
3212        BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> f_vec_scanner;
3213        match_scanner.init();
3214        f_vec_scanner.init();
3215        int lgth;
3216        for(j=0;j<MAX_COUNT;j++){
3217                lgth = gid_vec[j].size();
3218                int remaining = 0;
3219                Basis_bits temp_basis_bits;
3220                const int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
3221                int i = 0;
3222                int block_base;
3223               
3224                if(lgth != 0){ 
3225                        remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
3226                        for(i = 0;i < num_block; i++){
3227                                block_base = i*BLOCK_SIZE;
3228                                //cout << "block_base " << block_base << endl;
3229                       
3230                                s2p_do_block((BytePack*)(&(gid_vec[j][block_base])), temp_basis_bits);
3231                                //print_elem_vec(&((vector*)(gid_vec[j][block_base])),BLOCK_SIZE,j);
3232                                //print_basis_bits(temp_basis_bits);
3233
3234                                classify_bytes.do_block(temp_basis_bits,lex);
3235                                switch (j){
3236                                        case 2:
3237                                        validation_2.do_block(lex,output);
3238                                        f_vec_scanner.load_block(lex.cc2,i);
3239#ifdef DEBUG                           
3240                                        print_register("cc2",lex.cc2);
3241                                        print_register("match_2",output.matches);
3242#endif
3243                                        break;
3244                                        case 4:
3245                                        validation_4.do_block(lex,output);
3246                                        f_vec_scanner.load_block(lex.cc4,i);
3247#ifdef DEBUG
3248                                        print_register("cc4",lex.cc4);
3249                                        print_register("match_4",output.matches);
3250#endif
3251                                        break;
3252                                        case 9:
3253                                        validation_9.do_block(lex,output);
3254                                        f_vec_scanner.load_block(lex.cc9,i);
3255#ifdef DEBUG
3256                                        print_register("cc9",lex.cc9);
3257                                        print_register("match_9",output.matches);
3258#endif
3259                                        break;
3260                                }
3261
3262                                match_scanner.load_block(output.matches,i);
3263
3264                        }
3265                        if (remaining !=0){
3266                                block_base = i*BLOCK_SIZE;
3267                                //cout << "block_base " << block_base << endl;
3268                                BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
3269                                s2p_do_final_block((BytePack*)(&(gid_vec[j][block_base])), temp_basis_bits,EOF_mask);
3270                                //print_elem_vec(&((vector*)(gid_vec[j][block_base])),BLOCK_SIZE,j);
3271                                //print_basis_bits(temp_basis_bits);
3272                                //print_elem_vec((vector<char>*)(gid_vec[j][block_base]),remaining,j);
3273                       
3274                                classify_bytes.do_final_block(temp_basis_bits,lex,EOF_mask);
3275                                switch (j){
3276                                        case 2:
3277                                        validation_2.do_final_block(lex,output,EOF_mask);
3278                                        f_vec_scanner.load_block(lex.cc2,i);
3279#ifdef DEBUG
3280//                                      cout << remaining << endl;
3281                                        print_register("cc2",lex.cc2);
3282//                                      print_register("cc3",lex.cc3);
3283//                                      print_register("cc4",lex.cc4);
3284//                                      print_register("cc9",lex.cc9);
3285                                        print_register("match_2",output.matches);
3286#endif
3287                                        break;
3288                                        case 4:
3289                                        validation_4.do_final_block(lex,output,EOF_mask);
3290                                        f_vec_scanner.load_block(lex.cc4,i);
3291#ifdef DEBUG
3292                                        print_register("cc4",lex.cc4);
3293                                        print_register("match_4",output.matches);
3294#endif
3295                                        break;
3296                                        case 9:
3297                                        validation_9.do_final_block(lex,output,EOF_mask);
3298                                        f_vec_scanner.load_block(lex.cc9,i);
3299#ifdef DEBUG
3300                                        print_register("cc9",lex.cc9);
3301                                        print_register("match_9",output.matches);
3302#endif
3303                                        break;
3304                                }
3305                               
3306                                match_scanner.load_block(output.matches,i);
3307                        }
3308                }
3309        }
3310        if(lgth != 0){
3311                        vec_scan(match_scanner,f_vec_scanner,"Element",j);     
3312        }
3313       
3314
3315}
3316
3317
3318*/
3319
3320/*
3321static inline void validate(){
3322        struct Elem elem;
3323        Validation_1 validation_1;
3324        struct Lex lex;
3325        struct Output output;
3326        Classify_bytes classify_bytes;
3327        cout << "vector size " << gid_vec.size() << endl;
3328        int lgth = gid_vec.size();
3329        int remaining = 0;
3330        int current_pos = 0;
3331        Basis_bits temp_basis_bits;
3332
3333        ForwardScanner<BitBlock, ScanWord> match_scanner;
3334        ReverseScanner<BitBlock, ScanWord> vec_scanner;
3335        ForwardScanner<BitBlock, ScanWord> f_vec_scanner;
3336        int block_base = 0;
3337        if (lgth != 0){
3338                int i = 0;
3339                int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
3340                remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
3341                for (i = 0;i < num_block; i++){
3342//                      s2p_do_block((BytePack*)(vector_11[i]),temp_basis_bits);
3343                        s2p_do_block((BytePack*)(&(gid_vec[i])), temp_basis_bits);
3344                        print_elem_vec(&(gid_vec),lgth);
3345                        print_basis_bits(temp_basis_bits);
3346                       
3347                        classify_bytes.do_block(temp_basis_bits,lex);
3348                        validation_1.do_block(lex,output);
3349                       
3350                        match_scanner.init(&output.matches);
3351                        vec_scanner.init(&lex.cc1);
3352                        match_scanner.scan_to_next();
3353                        f_vec_scanner.init(&lex.cc1);
3354                        match_scanner.scan_to_next();
3355                        f_vec_scanner.scan_to_next();
3356                        current_pos = f_vec_scanner.get_pos();
3357                        vec_scanner.move_to(match_scanner.get_pos());
3358                        vec_scanner.scan_to_next();
3359//                      cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
3360                        if (vec_scanner.get_pos() != current_pos){
3361                                printf("#Mismatch found at pos: %d.\n",current_pos+block_base);
3362                        }
3363//                      out = simd_or(out,lex.cc1);
3364//                      print_register("out",out);
3365                       
3366                        while(!(match_scanner.is_done() || f_vec_scanner.is_done())){
3367                                f_vec_scanner.scan_to_next();
3368                                while(!(match_scanner.is_done())){
3369                                        match_scanner.scan_to_next();
3370                                        if(match_scanner.get_pos()>0){
3371                                                vec_scanner.move_to(match_scanner.get_pos());
3372                                                vec_scanner.scan_to_next();
3373                                        }
3374                                        if (vec_scanner.get_pos() != current_pos){
3375                                                        break;
3376                                        }
3377                                }
3378                                cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
3379                                if (f_vec_scanner.get_pos()>0){
3380                                        current_pos = f_vec_scanner.get_pos();
3381                                }
3382                                if (vec_scanner.get_pos() != current_pos){
3383                                        printf("Mismatch found at pos: %d.\n",current_pos+block_base);
3384                                }
3385//                              out = simd_or(out,lex.cc1);
3386//                              cout << "match_scanner_pos = " << match_scanner.get_pos() << endl;
3387//                              cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
3388//                              if(match_scanner.get_pos() == vec_scanner.get_pos()){
3389//                                      printf("Match found of element with id of '1'\n");                             
3390//                              }
3391                        }
3392                               
3393                       
3394//                      (BytePack*)(iter->second)
3395//                      validate_Elem_Vec.do_block(elem, temp_basis_bits);
3396                        cout << i ;
3397                        block_base += BLOCK_SIZE;
3398                }
3399                if (remaining !=0){
3400                        BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
3401                        s2p_do_final_block((BytePack*)(&(gid_vec[i])), temp_basis_bits,EOF_mask);
3402                        print_elem_vec(&(gid_vec),lgth);
3403                        print_basis_bits(temp_basis_bits);
3404                       
3405                        classify_bytes.do_block(temp_basis_bits,lex);
3406                        validation_1.do_block(lex,output);
3407                        print_register("output.matches",output.matches);
3408                        print_register("lex.cc1",lex.cc1);
3409                        match_scanner.init(&output.matches);
3410                        vec_scanner.init(&lex.cc1);
3411                        f_vec_scanner.init(&lex.cc1);
3412                        match_scanner.scan_to_next();
3413                        f_vec_scanner.scan_to_next();
3414                        current_pos = f_vec_scanner.get_pos();
3415                        cout << "current_pos = " << current_pos << endl;
3416//                      cout << "match_scanner_pos = " << match_scanner.get_pos()<< endl;
3417//                      cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
3418                        vec_scanner.move_to(match_scanner.get_pos());
3419                        vec_scanner.scan_to_next();
3420                        cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
3421                        if (vec_scanner.get_pos() != current_pos){
3422                                printf("#Mismatch found at pos: %d.\n",current_pos+block_base);
3423                        }
3424//                      out = simd_or(out,lex.cc1);
3425//                      print_register("out",out);
3426                       
3427                        while(!(match_scanner.is_done() || f_vec_scanner.is_done())){
3428                                f_vec_scanner.scan_to_next();
3429                                while(!(match_scanner.is_done())){
3430                                        match_scanner.scan_to_next();
3431                                        if(match_scanner.get_pos()>0){
3432                                                vec_scanner.move_to(match_scanner.get_pos());
3433                                                vec_scanner.scan_to_next();
3434                                        }
3435                                        if (vec_scanner.get_pos() != current_pos){
3436                                                        break;
3437                                        }
3438                                }
3439                                cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
3440                                if (f_vec_scanner.get_pos()>0){
3441                                        current_pos = f_vec_scanner.get_pos();
3442                                }
3443                                if (vec_scanner.get_pos() != current_pos){
3444                                        printf("Mismatch found at pos: %d.\n",current_pos+block_base);
3445                                }
3446//                              out = simd_or(out,lex.cc1);
3447//                              cout << "match_scanner_pos = " << match_scanner.get_pos() << endl;
3448//                              cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
3449//                              if(match_scanner.get_pos() == vec_scanner.get_pos()){
3450//                                      printf("Match found of element with id of '1'\n");                             
3451//                              }
3452                        }
3453//                      validate_Elem_Vec.do_final_block(elem, temp_basis_bits, EOF_mask);
3454                }
3455        }
3456/*
3457        vector<int> test;
3458        for(int i = 1;i <12; i++){
3459                test.push_back(i);
3460        }
3461//      int test[] = {1,2,3,4,5,6,7,8,9,10,11};
3462        Basis_bits temp_basis_bits;
3463        BitBlock EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-44));
3464        s2p_do_final_block((BytePack*)(&(test[0])), temp_basis_bits,EOF_mask);
3465        print_basis_bits(temp_basis_bits);
3466*/
3467/*
3468        for (map<char, vector<char>* > ::const_iterator iter = elem_vec_map.begin(); iter!= elem_vec_map.end(); ++iter){
3469                int i = 0;
3470                int lgth = (*(iter->second)).size();
3471                int remaining;
3472                if (lgth != 0){
3473                        cout <<"vector key "<< (int)iter->first << endl;
3474//                      cout <<"vector ptr" << iter->second<<endl;
3475               
3476                        cout <<"vector size: " << lgth << endl;
3477                        int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
3478                        remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
3479                        for (i = 0;i < num_block; i++){
3480                                Basis_bits temp_basis_bits;
3481                                s2p_do_block(((BytePack*)(&(*(iter->second))[i])), temp_basis_bits);
3482                                print_elem_vec(iter->second,lgth);
3483                                print_basis_bits(temp_basis_bits);
3484//                              (BytePack*)(iter->second)
3485                                cout << i ;
3486                        }
3487                        cout << endl;
3488                        if (remaining !=0){
3489                                BitBlock EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-remaining));
3490                                Basis_bits temp_basis_bits;
3491                                s2p_do_final_block(((BytePack*)(&(*(iter->second))[i])), temp_basis_bits,EOF_mask);
3492                                print_elem_vec((iter->second)+i,lgth);
3493                                print_basis_bits(temp_basis_bits);
3494                        }
3495                }                       
3496        }
3497*/
3498/*
3499}
3500*/
3501
3502static inline void vectoring(Tag_Callouts & tag_Callouts, Hash_data & hash_data,char *source,int block_base){
3503
3504        elem_starts = tag_Callouts.ElemName_starts;
3505    hashvalues[1] = hash_data.Hash_value;
3506   
3507//    pre_index.push(0);
3508   
3509        StreamScanLengthGrouping(source,block_base,(ScanBlock *) &tag_Callouts.ElemName_ends,(ScanBlock *) &tag_Callouts.Tag_closing, sizeof(BitBlock)/sizeof(ScanBlock),(ScanBlock *) &tag_Callouts.Content_starts,(ScanBlock *) &tag_Callouts.EndTag_marks);
3510       
3511        // Store the last starting position in case we hit boundary case
3512    previous_block_last_elem_start = - count_reverse_zeroes(elem_starts);
3513
3514    //copy current hash value data as previous one.
3515    memmove (&hashvalues[0], &hashvalues[1], 16);
3516}
3517/*
3518static inline void postprocess_do_block(Lex & lex, CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Check_streams & check_streams, Tag_Callouts & tag_Callouts, Hash_data & hash_data, int chars_avail){
3519
3520
3521    //NOTE: We are NOT handling the case for an extremely long symbol name (length > 1541).
3522    //      TagMatcher will crash if we feed a long symbol name.
3523    //      Sample file: test/long_sym_name.xml
3524
3525    tracker.StoreNewlines(lex.LF);
3526    elem_starts = tag_Callouts.ElemName_starts;
3527    hashvalues[1] = hash_data.Hash_value;
3528
3529        StreamScanLengthGrouping((ScanBlock *) &tag_Callouts.ElemName_ends,(ScanBlock *) &tag_Callouts.Tag_closing, sizeof(BitBlock)/sizeof(ScanBlock));
3530       
3531/*
3532    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_1) )
3533    {
3534        StreamScanLengthGrouping<1>((ScanBlock *) &tag_Callouts.ElemName_ends_1,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
3535    }
3536
3537    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_2) )
3538    {
3539        StreamScanLengthGrouping<2>((ScanBlock *) &tag_Callouts.ElemName_ends_2,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
3540    }
3541
3542    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_3) )
3543    {
3544        StreamScanLengthGrouping<3>((ScanBlock *) &tag_Callouts.ElemName_ends_3,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
3545    }
3546
3547    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_4) )
3548    {
3549        StreamScanLengthGrouping<4>((ScanBlock *) &tag_Callouts.ElemName_ends_4,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
3550    }
3551
3552    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_5) )
3553    {
3554        StreamScanLengthGrouping<5>((ScanBlock *) &tag_Callouts.ElemName_ends_5,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
3555    }
3556
3557    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_6) )
3558    {
3559        StreamScanLengthGrouping<6>((ScanBlock *) &tag_Callouts.ElemName_ends_6,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
3560    }
3561
3562    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_7) )
3563    {
3564        StreamScanLengthGrouping<7>((ScanBlock *) &tag_Callouts.ElemName_ends_7,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
3565    }
3566
3567    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_8) )
3568    {
3569        StreamScanLengthGrouping<8>((ScanBlock *) &tag_Callouts.ElemName_ends_8,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
3570    }
3571
3572    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_9) )
3573    {
3574        StreamScanLengthGrouping<9>((ScanBlock *) &tag_Callouts.ElemName_ends_9,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
3575    }
3576
3577    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_10) )
3578    {
3579        StreamScanLengthGrouping<10>((ScanBlock *) &tag_Callouts.ElemName_ends_10,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
3580    }
3581
3582    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_11) )
3583    {
3584        StreamScanLengthGrouping<11>((ScanBlock *) &tag_Callouts.ElemName_ends_11,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
3585    }
3586
3587    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_12) )
3588    {
3589        StreamScanLengthGrouping<12>((ScanBlock *) &tag_Callouts.ElemName_ends_12,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
3590    }
3591
3592    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_13) )
3593    {
3594        StreamScanLengthGrouping<13>((ScanBlock *) &tag_Callouts.ElemName_ends_13,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
3595    }
3596
3597    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_14) )
3598    {
3599        StreamScanLengthGrouping<14>((ScanBlock *) &tag_Callouts.ElemName_ends_14,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
3600    }
3601
3602    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_15) )
3603    {
3604        StreamScanLengthGrouping<15>((ScanBlock *) &tag_Callouts.ElemName_ends_15,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
3605    }
3606
3607    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_16) )
3608    {
3609        StreamScanLengthGrouping<16>((ScanBlock *) &tag_Callouts.ElemName_ends_16,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
3610    }
3611
3612    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_17_and_longer) )
3613    {
3614        StreamScanLengthGrouping<17>((ScanBlock *) &tag_Callouts.ElemName_ends_17_and_longer,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
3615    }
3616
3617*/
3618
3619
3620/*
3621    // Store the last starting position in case we hit boundary case
3622    previous_block_last_elem_start = - count_reverse_zeroes(elem_starts);
3623
3624    //copy current hash value data as previous one.
3625    memmove (&hashvalues[0], &hashvalues[1], 16);
3626
3627    if (bitblock::any(simd_or(check_streams.non_ascii_name_starts, check_streams.non_ascii_names))) {
3628      StreamScan((ScanBlock *) &check_streams.non_ascii_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), NameStrt_check);
3629      StreamScan((ScanBlock *) &check_streams.non_ascii_names, sizeof(BitBlock)/sizeof(ScanBlock), Name_check);
3630    }
3631
3632    if (bitblock::any(ctCDPI_Callouts.PI_name_starts)){
3633      StreamScan((ScanBlock *) &ctCDPI_Callouts.PI_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), PIName_check);
3634    }
3635
3636    if (bitblock::any(ctCDPI_Callouts.CD_starts)){
3637      StreamScan((ScanBlock *) &ctCDPI_Callouts.CD_starts, sizeof(BitBlock)/sizeof(ScanBlock), CD_check);
3638    }
3639
3640    if (bitblock::any(ref_Callouts.GenRef_starts)){
3641      StreamScan((ScanBlock *) &ref_Callouts.GenRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), GenRef_check);
3642    }
3643
3644    if (bitblock::any(ref_Callouts.DecRef_starts)){
3645      StreamScan((ScanBlock *) &ref_Callouts.DecRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), DecRef_check);
3646    }
3647
3648    if (bitblock::any(ref_Callouts.HexRef_starts)){
3649      StreamScan((ScanBlock *) &ref_Callouts.HexRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), HexRef_check);
3650    }
3651
3652    if (bitblock::any(check_streams.att_refs)){
3653      StreamScan((ScanBlock *) &check_streams.att_refs, sizeof(BitBlock)/sizeof(ScanBlock), AttRef_check);
3654    }
3655
3656//    error_tracker.If_Error_Report_First();
3657/*
3658    matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
3659    tracker.AdvanceBlock();
3660    */
3661    /*
3662}
3663*/
3664
3665static inline void print_GIDS()
3666{
3667    int span_count = gids.size();
3668    for(int i=0;i<span_count;i++) {
3669             cout << gids[i] << " ";
3670    }
3671    cout << endl;
3672}
3673
3674static inline int test(int)
3675{
3676    return 0;
3677}
3678
3679void do_process(FILE *infile, FILE *outfile) {
3680
3681        ///////////////
3682        //gid file
3683        ///////////////
3684        gid_writein = fopen("gid.out","w");
3685  struct U8 u8;
3686
3687  struct Lex lex;
3688
3689  struct Scope1 scope1;
3690
3691  struct Marker marker;
3692
3693  struct CtCDPI_Callouts ctCDPI_Callouts;
3694
3695  struct Ref_Callouts ref_Callouts;
3696
3697  struct Hash_data hash_data;
3698
3699  struct Tag_Callouts tag_Callouts;
3700
3701  struct Basis_bits basis_bits;
3702
3703  struct Check_streams check_streams;
3704
3705  struct Xml_names xml_names;
3706
3707  struct Elem elem;
3708
3709  struct Output output;
3710
3711
3712
3713        #ifndef STL_ALIGNED_VECTOR
3714                TagMatcher<SEGMENT_SIZE,LOOKAHEAD_SIZE> matcher;
3715        #endif
3716//#ifdef SYMBOL_TABLE
3717        if(Symbol){
3718        ///////////////////////////////////////////////////
3719        //preload element_IDs into symbol table from schema
3720        ///////////////////////////////////////////////////
3721        FILE *element_ID_in = fopen("../test/element_ID","r");
3722        char symbol[50];
3723        int index;
3724        if(element_ID_in == NULL){
3725                printf("Error opening element_ID file.\n");
3726                exit(0);
3727        }
3728        hashvalues[1] = hash_data.Hash_value;
3729        while(fscanf(element_ID_in,"%s %d\n",&symbol[0],&index)==2){
3730                int lgth = strlen(symbol);
3731                int hashvalue = compute_hash_value2(symbol,lgth);
3732//              cout << symbol <<" "<< lgth<<" "<<hashvalue << endl;
3733                int gid = 0;
3734                switch (lgth)
3735        {
3736                        case 1:
3737                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<1>(symbol, hashvalue);
3738                        break;
3739                        case 2:
3740                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<2>(symbol, hashvalue);
3741                        break;
3742                        case 3:
3743                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<3>(symbol, hashvalue);
3744                        break;
3745                        case 4:
3746                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<4>(symbol, hashvalue);
3747                        break;
3748                        case 5:
3749                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<5>(symbol, hashvalue);
3750                        break;
3751                        case 6:
3752                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<6>(symbol, hashvalue);
3753                        break;
3754                        case 7:
3755                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<7>(symbol, hashvalue);
3756                        break;
3757                        case 8:
3758                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<8>(symbol, hashvalue);
3759                        break;
3760                        case 9:
3761                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<9>(symbol, hashvalue);
3762                        break;
3763                        case 10:
3764                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<10>(symbol, hashvalue);
3765                        break;
3766                        case 11:
3767                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<11>(symbol, hashvalue);
3768                        break;
3769                        case 12:
3770                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<12>(symbol, hashvalue);
3771                        break;
3772                        case 13:
3773                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<13>(symbol, hashvalue);
3774                        break;
3775                        case 14:
3776                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<14>(symbol, hashvalue);
3777                        break;
3778                        case 15:
3779                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<15>(symbol, hashvalue);
3780                        break;
3781                        case 16:
3782                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<16>(symbol, hashvalue);
3783                        break;
3784                        default:
3785                        gid = pbgs_symbol_table.Lookup_or_Insert_Name(symbol, hashvalue, lgth);
3786                        break;         
3787                }
3788#ifdef DEBUG
3789                fprintf (gid_writein,"%s |  lgth: %i | hashvalue: %i | gid: %i | symbol: %s\n", __FUNCTION__,  lgth, hashvalue, gid, symbol);
3790#endif
3791        }       
3792        fclose(element_ID_in);
3793        }
3794//#endif
3795//      return;
3796
3797        int buffer_base = 0;
3798        int block_base = 0;
3799        int buffer_pos = 0;
3800        int block_pos = 0;
3801        int errpos = 0;
3802        int chars_avail = 0;
3803        int check_pos = 0;
3804        int chars_read = 0;
3805 
3806        //////////////////////////////////////////////////////////////////////////////////////////
3807    // Buffer Management
3808    //////////////////////////////////////////////////////////////////////////////////////////
3809                //      BitBlock buf[(BUFFER_SIZE)/sizeof(BitBlock)];
3810                //      uint8_t * src_buffer = (uint8_t *)buf + COPYBACK_SIZE;
3811
3812                #ifdef STL_ALIGNED_VECTOR
3813                        std::vector<uint8_t, AAllocator<uint8_t> > src_buffer;
3814                        src_buffer.reserve(BUFFER_SIZE);
3815                #else
3816                        char * COPYBACK;
3817                        char * src_buffer;
3818                        ALLOC_STATIC_ALIGNED_BYTE_BUFFER_WITH_COPYBACK(COPYBACK, src_buffer);
3819                #endif
3820  /*
3821  BytePack buf[(BUFFER_SIZE+BLOCK_SIZE+LOOKAHEAD_SIZE*2)/sizeof(SIMD_type)];
3822
3823  char * srcbuf = ((char *) buf) + LOOKAHEAD_SIZE;
3824  buffer_base = buf_pos;
3825  source = srcbuf;
3826  */
3827  chars_read = fread((void *)&src_buffer[0], 1, SEGMENT_SIZE, infile);
3828  chars_avail = chars_read;
3829  if (chars_avail > BUFFER_SIZE) chars_avail = SEGMENT_SIZE;
3830
3831  if(chars_read<4){
3832    fprintf(stderr,"File is too short. Not well formed.\n");
3833    exit(-1);
3834  }
3835
3836  Entity_Info * e = new Entity_Info;
3837  e->AnalyzeSignature((unsigned char *)&src_buffer[0]);
3838
3839  if (e->code_unit_base == ASCII) {
3840
3841    XML_Decl_Parser<ASCII> decl_parser((unsigned char *)&src_buffer[0]);
3842
3843    decl_parser.ReadXMLInfo(*e);
3844
3845    if (e->code_unit_size != SingleByte || (e->has_encoding_decl && (!at_UTF_8(e->encoding)))){
3846        fprintf(stderr,"Sorry, this xmlwf demo only works for UTF-8.\n");
3847        exit(-1);
3848    }
3849  }
3850  else {
3851    fprintf(stderr,"Sorry, this xmlwf demo does not process EBCDIC.\n");
3852        exit(-1);
3853  }
3854
3855  if (e->content_start != 0) {
3856        memmove(&src_buffer[0], &src_buffer[e->content_start], chars_read - e->content_start);
3857        buffer_pos = e->content_start;
3858//      buffer_base = buffer_pos;
3859        if ((chars_avail-e->content_start) < SEGMENT_SIZE) {
3860                        chars_read = chars_avail - e->content_start + fread(&src_buffer[chars_avail-e->content_start], 1, e->content_start, infile);
3861                        chars_avail = chars_read;
3862                }
3863                if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
3864  }
3865
3866        //////////////////////////////////////////////////////////////////////////////////////////
3867        // Read OVERLAP bytes to support post processing validation lookahead.
3868        //////////////////////////////////////////////////////////////////////////////////////////
3869        chars_read = chars_avail + fread(&src_buffer[chars_avail], 1, LOOKAHEAD_SIZE, infile);
3870        chars_avail = chars_read;
3871        if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
3872
3873  Parse_refs parse_refs;
3874  Parse_tags parse_tags;
3875  Classify_bytes_Validate_utf8 classify_bytes_Validate_utf8;
3876  Parse_CtCDPI parse_CtCDPI;
3877  Validation_9 validation_9;
3878  Do_check_streams do_check_streams;
3879  Classify_bytes classify_bytes;
3880  Validation_2 validation_2;
3881  Validate_xml_names validate_xml_names;
3882  Validation_4 validation_4;
3883  Validate_content_5 validate_content_5;
3884  Add_scope_streams add_scope_streams;
3885
3886
3887        #ifndef STL_ALIGNED_VECTOR
3888        matcher.setSrc((char *)&src_buffer[0]);
3889        #endif
3890
3891/* Full Buffers */
3892    int block_segment_num = 0;
3893    while (chars_avail >= SEGMENT_SIZE) {
3894      PERF_SEC_START(parser_timer);
3895      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
3896//              cout << "loops" << ends;
3897                block_base = blk*BLOCK_SIZE;
3898        s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
3899     
3900               
3901  classify_bytes_Validate_utf8.do_block(basis_bits, lex, u8);
3902  add_scope_streams.do_block(lex, scope1);
3903  parse_CtCDPI.do_block(lex, marker, ctCDPI_Callouts, check_streams);
3904  parse_tags.do_block(lex, marker, tag_Callouts);
3905  parse_refs.do_block(lex, marker, ref_Callouts);
3906  validate_xml_names.do_block(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, check_streams);
3907  do_check_streams.do_block(marker, tag_Callouts, check_streams);
3908         
3909                tracker.StoreNewlines(lex.LF);
3910//              cout << "post start" << endl;
3911//              postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
3912                postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
3913//#ifdef SYMBOL_TABLE
3914                if(Symbol)
3915                vectoring(tag_Callouts,hash_data,(char *)&src_buffer[0],block_base);
3916//#endif
3917//              cout << "post done" << endl;
3918                #ifndef STL_ALIGNED_VECTOR
3919                matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
3920                #endif
3921                tracker.AdvanceBlock();
3922//              cout << "loop" << endl;
3923      }
3924      #ifndef STL_ALIGNED_VECTOR
3925      matcher.StreamScan(chars_avail);
3926      matcher.Advance_buffer();
3927      #endif
3928      PERF_SEC_END(parser_timer, chars_avail);
3929//        cout << "here" << endl;
3930      int bytes_left = chars_read - chars_avail;
3931     
3932      //////////////////
3933      //element name buffer, for scanning element name backwards
3934      /////////////////
3935      memmove(&element_name_buffer[0],&src_buffer[SEGMENT_SIZE-ELEMENT_BUFFER_SIZE],ELEMENT_BUFFER_SIZE);
3936//      fprintf(gid_writein,"name_buffer\n");
3937      cross_buffer_flag = 1;
3938     
3939      memmove(&src_buffer[0], &src_buffer[SEGMENT_SIZE], LOOKAHEAD_SIZE);
3940      chars_read = fread(&src_buffer[LOOKAHEAD_SIZE],1,SEGMENT_SIZE, infile) + LOOKAHEAD_SIZE;
3941      chars_avail = chars_read;
3942//      cout << "here" << endl;
3943      if (chars_avail > SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
3944      buffer_pos += chars_avail;
3945      buffer_base = buffer_pos;
3946      block_segment_num++;
3947
3948  }
3949       
3950/* Final Partial Buffer */
3951    PERF_SEC_START(parser_timer);
3952
3953    block_pos = 0;
3954    int remaining = chars_avail;
3955
3956
3957
3958/* Full Blocks */
3959    while (remaining >= BLOCK_SIZE) {
3960          block_base = block_pos;
3961          s2p_do_block((BytePack *) &src_buffer[block_pos], basis_bits);
3962         
3963         
3964  classify_bytes_Validate_utf8.do_block(basis_bits, lex, u8);
3965  add_scope_streams.do_block(lex, scope1);
3966  parse_CtCDPI.do_block(lex, marker, ctCDPI_Callouts, check_streams);
3967  parse_tags.do_block(lex, marker, tag_Callouts);
3968  parse_refs.do_block(lex, marker, ref_Callouts);
3969  validate_xml_names.do_block(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, check_streams);
3970  do_check_streams.do_block(marker, tag_Callouts, check_streams);
3971         
3972          tracker.StoreNewlines(lex.LF);
3973//        cout << "post start1" << endl;
3974         
3975//        postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
3976          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
3977//#ifdef SYMBOL_TABLE
3978        if(Symbol)
3979          vectoring(tag_Callouts,hash_data,(char *)&src_buffer[0],block_base);
3980//#endif
3981//        cout << "post end2" << endl;
3982          #ifndef STL_ALIGNED_VECTOR
3983          matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
3984          #endif
3985          tracker.AdvanceBlock();
3986          block_pos += BLOCK_SIZE;
3987          remaining -= BLOCK_SIZE;
3988    }
3989    block_base = block_pos;
3990        #ifdef USE_ANY_CARRY_TEST
3991    if (remaining > 0 || parse_refs.carryQ.CarryTest(0, 6) || parse_tags.carryQ.CarryTest(0, 13) || classify_bytes_Validate_utf8.carryQ.CarryTest(0, 12) || parse_CtCDPI.carryQ.CarryTest(0, 19) || validation_9.carryQ.CarryTest(0, 10) || 0 || 0 || validation_2.carryQ.CarryTest(0, 12) || validate_xml_names.carryQ.CarryTest(0, 9) || validation_4.carryQ.CarryTest(0, 10) || validate_content_5.carryQ.CarryTest(0, 12) || add_scope_streams.carryQ.CarryTest(0, 2)) {
3992        #endif
3993          EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
3994          s2p_do_final_block((BytePack *) &src_buffer[block_pos], basis_bits, EOF_mask);
3995         
3996  classify_bytes_Validate_utf8.do_final_block(basis_bits, lex, u8, EOF_mask);
3997  add_scope_streams.do_final_block(lex, scope1, EOF_mask);
3998  parse_CtCDPI.do_final_block(lex, marker, ctCDPI_Callouts, check_streams, EOF_mask);
3999  parse_tags.do_final_block(lex, marker, tag_Callouts, EOF_mask);
4000  parse_refs.do_final_block(lex, marker, ref_Callouts, EOF_mask);
4001  validate_xml_names.do_final_block(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, check_streams, EOF_mask);
4002  do_check_streams.do_final_block(marker, tag_Callouts, check_streams, EOF_mask);
4003//        cout << "post start3" << endl;
4004//        postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
4005          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
4006//#ifdef SYMBOL_TABLE
4007        if(Symbol)
4008          vectoring(tag_Callouts,hash_data,(char *)&src_buffer[0],block_base);
4009//#endif
4010//        cout << "post end3" << endl;
4011          #ifndef STL_ALIGNED_VECTOR
4012      matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
4013          #endif
4014          tracker.AdvanceBlock();
4015        #ifdef USE_ANY_CARRY_TEST
4016    }
4017    #endif
4018    buffer_pos += chars_avail;
4019    buffer_base = buffer_pos;
4020        #ifndef STL_ALIGNED_VECTOR
4021    matcher.StreamScan(chars_avail);
4022    matcher.Advance_buffer();
4023//    tracker.Advance_buffer();
4024
4025   
4026    if (matcher.depth != 0) {
4027      fprintf(stderr, "tag matching error (depth %i) at position %i\n", matcher.depth, buffer_base);
4028      exit(-1);
4029     
4030     
4031    }
4032    #endif
4033    PERF_SEC_END(parser_timer, chars_avail);
4034//  print_GIDS();
4035//    pbgs_symbol_table.Print_Symbol_Table_Distribution();
4036}
4037
4038
4039
4040int
4041main(int argc, char * argv[]) {
4042        char * infilename, * outfilename;
4043        FILE *infile, *outfile;
4044        struct stat fileinfo;
4045
4046        if (argc < 2) {
4047                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
4048                exit(-1);
4049        }
4050
4051        infilename = argv[1];
4052        stat(infilename, &fileinfo);
4053        infile = fopen(infilename, "rb");
4054        if (!infile) {
4055                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
4056                exit(-1);
4057        }
4058
4059        if (argc < 3) outfile = stdout;
4060        else {
4061                outfilename = argv[2];
4062                outfile = fopen(outfilename, "wb");
4063                if (!outfile) {
4064                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
4065                        exit(-1);
4066                }
4067        }
4068
4069        if (argc == 4){
4070                if(strcmp(argv[3],"-s")==0){
4071                        Symbol = 1;
4072                        Content_model = 0;
4073                        Datatype = 0;
4074                        //Debug = 0;
4075                }else if(strcmp(argv[3],"-c")==0){
4076                        Symbol = 1;
4077                        Content_model = 1;
4078                        Datatype = 0;
4079                        Content_gather = 1;
4080                }else if(strcmp(argv[3],"-d")==0){
4081                        Symbol = 1;
4082                        Content_model = 0;
4083                        Datatype = 1;
4084                }else if(strcmp(argv[3],"-a")==0){
4085                        Symbol = 1;
4086                        Content_model = 1;
4087                        Datatype = 1;
4088                }else if(strcmp(argv[3],"-g")==0){
4089                        Symbol = 1;
4090                        Datatype = 1;
4091                        Data_gather = 1;
4092                        Content_model = 0;
4093                }else if(strcmp(argv[3],"-v")==0){
4094                        Symbol = 1;
4095                        Content_model = 1;
4096                        Datatype = 0;
4097                        Content_gather = 1;
4098                }
4099        }
4100
4101//      PERF_SEC_BIND(1);
4102
4103        PERF_SEC_INIT(parser_timer);
4104
4105        do_process(infile, outfile);
4106       
4107#if DEBUG
4108//print_gid_vec();
4109#endif
4110        //cout << "validate start" << endl;
4111        //validate();
4112//#ifdef CONTENT_MODEL
4113        if(Symbol && Content_model && !Content_gather)
4114                validate_mul_block();
4115//#endif
4116        PERF_SEC_DUMP(parser_timer);
4117
4118        PERF_SEC_DESTROY(parser_timer);
4119
4120        fclose(infile);
4121        fclose(outfile);
4122
4123        printf ("Done procressing\n");
4124        return(0);
4125}
Note: See TracBrowser for help on using the repository browser.