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

Last change on this file since 3219 was 3219, checked in by shiyangy, 6 years ago
File size: 130.3 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 DEBUG 1
17//#define BLOCK_SIZE (sizeof(SIMD_type) * 8)
18//#define SEGMENT_BLOCKS 12
19//#define BUFFER_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
20//#define OVERLAP_BUFSIZE 2*(sizeof(SIMD_type))
21
22#define VECTOR_WIDTH 8
23#define VECTOR_TYPE (char)
24
25#include <stdio.h>
26#include <stdlib.h>
27#include <errno.h>
28#include <sys/types.h>
29#include <sys/stat.h>
30#include <limits.h>
31
32#include <simd-lib/s2p.hpp>
33#include <simd-lib/buffer.hpp>
34#include <simd-lib/bitblock_iterator.hpp>
35#include <simd-lib/perflib/perfsec.h>
36
37//#include "../lib/lib_simd.h"
38#include "../symtab/pbgs_identity_symbol_table.h"
39
40#include <stack>
41#include <map>
42#include <vector>
43
44#include <queue>
45#include <string>
46
47typedef long ScanBlock;
48typedef BytePack BitBlock;
49
50using namespace std;
51
52//#include "../lib/carryQ.h"
53#include <xmldecl.h>
54//#include "xml_error.c"
55//#include "xmldecl.c"
56#include <namechars.h>
57#include <LineColTracker.hpp>
58#include <XMLTestSuiteError.h>
59
60// Define the mappings for pablo.assert_0(strm, errkind) statements which
61// compile to the the form assert_0_error(errkind, strm)
62#include <ErrorTracker.h>
63
64ErrorTracker error_tracker;
65#define assert_0_error(errkind, errstrm) error_tracker.NoteError(errkind, errstrm);
66
67#ifndef STL_ALIGNED_VECTOR
68#include <TagMatcher.hpp>
69#endif
70
71#ifdef STL_ALIGNED_VECTOR // experimental, comment out TagMatcher code to use STL aligned memory vector
72#warning "Compiling with experimental STL_ALIGNED_VECTOR."
73#include <vector>
74#include <simd-lib/stl_aligned_allocator.hpp>
75#endif
76
77#ifdef BUFFER_PROFILING
78        BOM_Table * parser_timer;
79
80#elif CODE_CLOCKER
81        #define NUM_EVENTS 1
82        int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
83        //int Events[NUM_EVENTS] = {PAPI_L2_DCM};
84        //int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
85        int cal_size = 20;
86        CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
87#else
88        void * parser_timer;
89#endif
90
91//////////////////////////////////////////////////////////////////////////////////////////
92// Buffer Management // WARNING: Do Not update #defines. Results in TagMatcher errors.
93//////////////////////////////////////////////////////////////////////////////////////////
94#define PADDING_BLOCKS 0
95#define PADDING_SIZE (BLOCK_SIZE * PADDING_BLOCKS)
96#define COPYBACK_BLOCKS 2
97#define COPYBACK_SIZE (BLOCK_SIZE * COPYBACK_BLOCKS)
98#define LOOKAHEAD_BLOCKS 1
99#define LOOKAHEAD_SIZE (BLOCK_SIZE * LOOKAHEAD_BLOCKS)
100#define SEGMENT_BLOCKS  12 // WARNING: TagMatcher.hpp causes xmlconf test suite failures for SEGMENT_BLOCKS < 3.
101#define SEGMENT_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
102#define BUFFER_SIZE (COPYBACK_SIZE + SEGMENT_SIZE + LOOKAHEAD_SIZE + PADDING_SIZE)
103
104
105
106//int block_base=0;
107//int buffer_base=0;
108int buffer_last;
109FILE *gid_writein;
110#define ELEMENT_BUFFER_SIZE 30
111char element_name_buffer[ELEMENT_BUFFER_SIZE];
112int cross_buffer_flag = 0;
113//char * source;
114LineColTracker tracker;
115
116static inline int cfzl(long x){
117        unsigned long ux = x;
118        if (x<0){
119                ux = ULONG_MAX + x + 1;
120        }
121        if (ux==0)
122                return 8*sizeof(long);
123        int n;
124        n = 0;
125        while (1){
126                if ((ux%2) == 1){
127                        if(n==64){
128                                cout << ux <<endl;
129                        }
130                        return n;               
131                }
132                n ++;
133                ux = ux >> 1;
134                //cout << "x = " << x << endl;
135        } 
136}
137
138static inline void print_gid_vec();
139/*
140static inline int cfzl(long x){
141 if (x ==0)
142  return 32;
143 int n=0;
144 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
145 if ((x & 0xFF000000) == 0){ n = n +  8; x = x <<  8;} // 8 left bits are 0
146 if ((x & 0xF0000000) ==0){ n = n +  4; x = x <<  4;} // 4 left bits are 0
147 if ((x & 0xC0000000) == 0){ n =n +  2, x = x <<  2;}  // 110000....0 2 left bits are zero
148 if ((x & 0x80000000) == 0){n = n +  1, x = x <<  1;} // first left bit is zero
149 return n;
150
151}
152*/
153static inline void ReportError(const char * error_msg, int error_pos_in_block) {
154  int error_line, error_column;
155  tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
156  fprintf(stderr, "%s at line %i, column %i\n", error_msg, error_line, error_column);
157}
158/*
159class ErrorTracker {
160public:
161    ErrorTracker() { noted_pos_in_block = -1;}
162
163    inline void NoteError(const char * error_msg, BitBlock err_strm) {
164      int pos_in_block = count_forward_zeroes(err_strm);
165      if ((noted_pos_in_block == -1) || (noted_pos_in_block > pos_in_block)) {
166        noted_pos_in_block = pos_in_block;
167        noted_error = error_msg;
168      }
169    }
170
171    inline void If_Error_Report_First() {
172      if (noted_pos_in_block > -1) {
173              int error_line, error_column;
174              ReportError(noted_error, noted_pos_in_block);
175              exit(-1);
176      }
177    }
178
179private:
180  const char * noted_error;
181  int noted_pos_in_block;
182};
183*/
184
185
186//BitBlock EOF_mask = simd_const_1(1);
187
188//ErrorTracker error_tracker;
189BitBlock elem_starts;
190int previous_block_last_elem_start;
191BytePack hashvalues[2];
192
193vector <int> gids;
194PBGSIdentitySymbolTable pbgs_symbol_table;
195
196vector <char> gid_vec;
197
198stack <vector<char>* > elem_vec_stack;
199map<char, vector<char>* > elem_vec_map;
200
201static inline int ScanBackwardPos(BitBlock * block, int pos)
202{
203        cout << "pos " << pos << endl;
204    BitBlock s = block[0];
205    if (bitblock::any(block[0])){
206        print_register("zero",block[0]);
207        print_register("t",simd_not(simd<128>::sll(simd<1>::constant<1>(), convert(pos))) );
208        }
209    BitBlock temp = simd_and( s, simd_not(simd<128>::sll(simd<1>::constant<1>(), convert(pos))) );
210//      print_register("zero",simd_not(simd<128>::sll(simd<1>::constant<1>());
211                print_register("temp",temp);
212    if (bitblock::any(temp))
213    {
214        // sizeof (BitBlock)*8 - cbzl( s & ~(~0 << pos)) - 1;
215//      cout << "block_size" << BLOCK_SIZE << endl;
216        return BLOCK_SIZE - count_reverse_zeroes(temp) - 1;
217    }
218    else
219    {
220        //handle boundary case
221        return previous_block_last_elem_start - 1;
222    }
223}
224
225static inline int StreamScan(ScanBlock * stream, int blk_count, int ProcessPos(int)) {
226        int blk;
227        int block_pos = 0;
228        for (blk = 0; blk < blk_count; blk++) {
229                ScanBlock s = stream[blk];
230                while(s) {
231                        int code = (ProcessPos(cfzl(s) + block_pos));
232                        if (code) return code;
233                        s = s & (s-1);  // clear rightmost bit.
234                }
235                block_pos += 8 * sizeof(ScanBlock);
236        }
237        return 0;
238}
239
240static inline int compute_hash_value (int lgth, int start)
241{
242    unsigned int offset_bit = start + 128;
243    uint64_t stream = *((uint64_t*)(((uint32_t*)hashvalues)+(offset_bit>>5)));
244    return stream >> (offset_bit & 0x1F) & ~(~0 << lgth);
245}
246/*
247template <int L>
248static inline int ElemEnd_grouping(int pos) {
249    int end = block_base + pos;
250    int start = end - L;
251    int hashvalue = compute_hash_value(L, start - block_base);
252    int gid = pbgs_symbol_table.Lookup_or_Insert_Name<L>(source + start, hashvalue);
253    gids.push_back(gid);
254#if DEBUG
255    char* symbol = new char[L+1];
256    strncpy ( symbol, source + start, L );
257    symbol[L] ='\0';
258    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 );
259    delete symbol; symbol = 0;
260#endif
261    return gid;
262}
263
264template<>
265inline int ElemEnd_grouping<17>(int pos) {
266    int end = block_base + pos;
267    int start = ScanBackwardPos (&elem_starts, pos) + block_base;
268    int lgth = end - start;
269    int hashvalue = compute_hash_value(lgth, start - block_base);
270    int gid = 0;
271
272//    if (lgth < 32)
273//    {
274//      gid = pbgs_symbol_table.Lookup_or_Insert_Name_32(source + start, hashvalue, lgth);
275//    }
276//    else
277    {
278        gid = pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
279    }
280    gids.push_back(gid);
281#if DEBUG
282    char* symbol = new char[lgth+1];
283    strncpy ( symbol, source + start, lgth );
284    symbol[lgth] ='\0';
285    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);
286#endif
287    return gid;
288}
289*/
290
291inline char ElemEnd_grouping(char *source,int block_base,int pos) {
292    int end = block_base + pos;
293    int start = ScanBackwardPos(&elem_starts, pos) + block_base;
294    ///////////////////////
295    //start could be negitive
296    //the element name falls in two buffers
297    ///////////////////////
298    char *name = source + start;
299    char name_buffer[50];
300   
301    if (start<0){
302        memmove (&name_buffer[0],&element_name_buffer[ELEMENT_BUFFER_SIZE+start],-start);       
303        memmove (&element_name_buffer[ELEMENT_BUFFER_SIZE+start],&source[0],50+start);
304        name = name_buffer;
305    }
306//    cout << end << "  " << start << endl;
307    int lgth = end - start;
308    int hashvalue = compute_hash_value(lgth, start - block_base);
309    char gid = 0;
310
311
312//    if (lgth < 32)
313//    {
314//      gid = pbgs_symbol_table.Lookup_or_Insert_Name_32(source + start, hashvalue, lgth);
315//    }
316//    else
317
318        switch (lgth)
319    {
320    case 1:
321        gid = pbgs_symbol_table.Lookup_or_Insert_Name<1>(source + start, hashvalue);
322        break;
323    case 2:
324        gid = pbgs_symbol_table.Lookup_or_Insert_Name<2>(source + start, hashvalue);
325        break;
326    case 3:
327        gid = pbgs_symbol_table.Lookup_or_Insert_Name<3>(source + start, hashvalue);
328        break;
329    case 4:
330        gid = pbgs_symbol_table.Lookup_or_Insert_Name<4>(source + start, hashvalue);
331        break;
332    case 5:
333        gid = pbgs_symbol_table.Lookup_or_Insert_Name<5>(source + start, hashvalue);
334        break;
335    case 6:
336        gid = pbgs_symbol_table.Lookup_or_Insert_Name<6>(source + start, hashvalue);
337        break;
338    case 7:
339        gid = pbgs_symbol_table.Lookup_or_Insert_Name<7>(source + start, hashvalue);
340        break;
341    case 8:
342        gid = pbgs_symbol_table.Lookup_or_Insert_Name<8>(source + start, hashvalue);
343        break;
344    case 9:
345        gid = pbgs_symbol_table.Lookup_or_Insert_Name<9>(source + start, hashvalue);
346        break;
347    case 10:
348        gid = pbgs_symbol_table.Lookup_or_Insert_Name<10>(source + start, hashvalue);
349        break;
350    case 11:
351        gid = pbgs_symbol_table.Lookup_or_Insert_Name<11>(source + start, hashvalue);
352        break;
353    case 12:
354        gid = pbgs_symbol_table.Lookup_or_Insert_Name<12>(source + start, hashvalue);
355        break;
356    case 13:
357        gid = pbgs_symbol_table.Lookup_or_Insert_Name<13>(source + start, hashvalue);
358        break;
359    case 14:
360        gid = pbgs_symbol_table.Lookup_or_Insert_Name<14>(source + start, hashvalue);
361        break;
362    case 15:
363        gid = pbgs_symbol_table.Lookup_or_Insert_Name<15>(source + start, hashvalue);
364        break;
365    case 16:
366        gid = pbgs_symbol_table.Lookup_or_Insert_Name<16>(source + start, hashvalue);
367        break;
368    default:
369        gid = pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
370        break;
371    }
372/*
373    {
374        gid = (char)pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
375    }
376*/
377    gids.push_back(gid);
378#if DEBUG
379    char* symbol = new char[lgth+1];
380    strncpy ( symbol, source + start, lgth );
381    symbol[lgth] ='\0';
382    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);
383    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);
384#endif
385    return gid;
386}
387
388//template <int L>
389static inline int StreamScanLengthGrouping(char *source,int block_base,ScanBlock * stream, ScanBlock * stream2, int blk_count) {
390    int blk;
391    int block_pos = 0;
392//    cout << "cfzl():" << cfzl() << endl;
393//      long test = 6;
394//      test = (test & (test - 1));
395//      cout << test << endl;
396    for (blk = 0; blk < blk_count; blk++) {
397        cout << "blk:" << blk << endl;
398   
399                ScanBlock s = stream[blk];
400                ScanBlock s2 = stream2[blk];
401//              cout << s << "  " << s2 << endl;
402//              print_register("s:",((BitBlock*)stream)[0]);
403                while(s | s2) {
404                        cout << "cfzl(s):" << cfzl(s)<<endl;
405                    int end_pos = cfzl(s) + block_pos;
406//                  cout << "s2 " << s2 << endl;
407                    int end_tag = cfzl(s2) + block_pos;
408//              cout << "cfzl(s):" << cfzl(s)<<endl;
409//              cout << "cfzl(s2):" << cfzl(s2)<<endl;
410//                      cout << (end_tag < end_pos && s2 != 0)<< "||" <<(s == 0 && s2 != 0)  << endl;
411                        if ((end_tag < end_pos && s2 != 0) | (s == 0 && s2 != 0)){
412                        cout << "here" << endl;
413                        cout << "closing tag" << endl;
414//                      cout << "endtag:" << end_tag << " " << end_pos<<endl;
415//                      cout << "1"<< endl;
416//                      cout << elem_vec_stack.size()<<endl;
417//                      cout << "2" << endl;
418//                      cout << elem_vec_stack.top()<<endl;
419                                if(!(gid_vec.empty())){
420//                                      if(gid_vec.back() != 0){
421                                                gid_vec.push_back(0);
422//                                      }
423                                }
424                                cout << "before" << s2 << endl;
425                                s2 = s2 & (s2 - 1);
426                                cout << "after" << s2 << endl;
427//                      cout << "s2 = " << s2 << endl;
428                }else{
429                        cout << " end_pos == " << end_pos<<endl;
430                        cout << " end_tag_pos == " << end_tag << endl;
431                        char gid = ElemEnd_grouping(source,block_base,end_pos);
432                        if (s!=0){
433                                s = s & (s-1);  // clear rightmost bit.
434                        }
435                        //else{
436                        //      s2 = s2 & (s2 - 1);
437                        //}
438                                if (gid != 0){
439                                        gid_vec.push_back(gid);                 
440                                }
441                                cout << "here1" << endl;
442                }
443                }
444                block_pos += 8 * sizeof(ScanBlock);
445                print_gid_vec();
446    }
447    return 0;
448}
449
450void print_gid_vec(){
451        for (int i = 0; i < gid_vec.size(); i++){
452                cout << (int)gid_vec[i] << " ";
453        }
454        cout << endl;
455/*     
456        int i = 1;
457        int lst[256] = {0};
458        cout << elem_vec_map.size() << " vectors" << endl;
459        for (int i = 0;i < gids.size(); i++){
460                if (lst[gids[i]] == 0){
461                        cout << "gid: " << gids[i] << endl;
462                        lst[gids[i]] = 1;
463                        vector<char> *tmp = elem_vec_map[gids[i]];
464                        cout << "vector size:"<< (*tmp).size()<<endl;
465                        if ((*tmp).size()!=0){
466                                cout << "elements: ";
467                                for (int j = 0; j < (*tmp).size();j++){
468                                        cout << (int)(*tmp)[j] << " ";
469                                }
470                                cout << endl;
471                        }
472                        cout << endl;
473                }
474        }
475*/
476}
477/*
478static inline int NameStrt_check(int pos) {
479        int block_pos = block_base + pos;
480        if(XML_10_UTF8_NameStrt_bytes((unsigned char*)&source[block_pos]) == 0){
481              ReportError("name start error", pos);
482              exit(-1);
483        }
484        return 0;
485}
486
487static inline int Name_check(int pos) {
488        int block_pos = block_base + pos;
489        if(XML_10_UTF8_NameChar_bytes((unsigned char*)&source[block_pos]) == 0){
490              ReportError("name error", pos);
491              exit(-1);
492        }
493        return 0;
494}
495
496static inline int PIName_check(int pos) {
497        int block_pos = block_base + pos;
498        int file_pos = block_pos+buffer_base;
499        printf ("%s:%i\n",__FUNCTION__,pos);
500        if (at_XxMmLll<ASCII>((unsigned char*)&source[block_pos]) && (source[block_pos+3]=='?' || source[block_pos+3]<= ' ')) {
501              // "<?xml" legal at start of file.
502              if ((file_pos == 2) && at_XmlDecl_start<ASCII>((unsigned char*)&source[0])) return 0;
503              ReportError("[Xx][Mm][Ll] illegal as PI name", pos);
504              exit(-1);
505        }
506        return 0;
507}
508
509static inline int CD_check(int pos) {
510        int block_pos = block_base + pos;
511        if (!at_CDATA1<ASCII>((unsigned char*)&source[block_pos])){
512              ReportError("CDATA error", pos);
513              exit(-1);
514        }
515        return 0;
516}
517
518static inline int GenRef_check(int pos) {
519        int block_pos = block_base + pos;
520        unsigned char* s = (unsigned char*)&source[block_pos];
521        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))){
522                        cout << pos << endl;
523              ReportError("Undefined reference", pos);
524              exit(-1);
525        }
526        return 0;
527}
528
529static inline int HexRef_check(int pos) {
530        int block_pos = block_base + pos;
531        unsigned char* s = (unsigned char*)&source[block_pos];
532        int ch_val = 0;
533        while(at_HexDigit<ASCII>(s)){
534          ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
535          if (ch_val> 0x10FFFF ){
536            ReportError("Illegal character reference", pos);
537            exit(-1);
538          }
539          s++;
540        }
541        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
542          ReportError("Illegal character reference", pos);
543          exit(-1);
544        }
545        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
546          ReportError("Illegal XML 1.0 character reference", pos);
547          exit(-1);
548        }
549        return 0;
550}
551
552static inline int DecRef_check(int pos) {
553        int block_pos = block_base + pos;
554        unsigned char* s = (unsigned char*)&source[block_pos];
555        int ch_val = 0;
556        while(at_HexDigit<ASCII>(s)){
557          ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
558          if (ch_val> 0x10FFFF ){
559            ReportError("Illegal character reference", pos);
560            exit(-1);
561          }
562          s++;
563        }
564        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
565          ReportError("Illegal character reference", pos);
566          exit(-1);
567        }
568        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
569          ReportError("Illegal XML 1.0 character reference", pos);
570          exit(-1);
571        }
572        return 0;
573}
574
575static inline int AttRef_check(int pos) {
576        int block_pos = block_base + pos;
577        unsigned char* s = (unsigned char*)&source[block_pos];
578        int ch_val = 0;
579        if(s[0]=='#'){
580          s++;
581          if(s[0]=='x' || s[0]=='X'){
582            s++;
583            while(at_HexDigit<ASCII>(s)){
584              ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
585              s++;
586            }
587          }
588          else{
589            while(at_HexDigit<ASCII>(s)){
590              ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
591              s++;
592            }
593          }
594          if (ch_val==60){
595            ReportError("Attribute values contain '<' characters after reference expansion", pos);
596            exit(-1);
597          }
598        }
599        else if(at_Ref_lt<ASCII>(s)){
600          ReportError("Attribute values contain '<' characters after reference expansion", pos);
601          exit(-1);
602        }
603        return 0;
604}
605*/
606
607
608
609  struct U8 {
610  BitBlock unibyte;
611  BitBlock prefix;
612  BitBlock prefix2;
613  BitBlock prefix3;
614  BitBlock prefix4;
615  BitBlock suffix;
616  BitBlock badprefix;
617  BitBlock xE0;
618  BitBlock xED;
619  BitBlock xF0;
620  BitBlock xF4;
621  BitBlock xA0_xBF;
622  BitBlock x80_x9F;
623  BitBlock x90_xBF;
624  BitBlock x80_x8F;
625  BitBlock xEF;
626  BitBlock xBF;
627  BitBlock xBE;
628  BitBlock scope22;
629  BitBlock scope32;
630  BitBlock scope33;
631  BitBlock scope42;
632  BitBlock scope43;
633  BitBlock scope44;
634  BitBlock xE0_scope;
635  BitBlock xED_scope;
636  BitBlock xF0_scope;
637  BitBlock xF4_scope;
638  BitBlock xEF_scope;
639};
640
641  struct Lex {
642  BitBlock CR;
643  BitBlock LF;
644  BitBlock HT;
645  BitBlock SP;
646  BitBlock CRLF;
647  BitBlock RefStart;
648  BitBlock Semicolon;
649  BitBlock Colon;
650  BitBlock LAngle;
651  BitBlock RAngle;
652  BitBlock LBracket;
653  BitBlock RBracket;
654  BitBlock Exclam;
655  BitBlock QMark;
656  BitBlock Hyphen;
657  BitBlock Equals;
658  BitBlock SQuote;
659  BitBlock DQuote;
660  BitBlock Slash;
661  BitBlock Hash;
662  BitBlock x;
663  BitBlock ASCII_name_start;
664  BitBlock ASCII_name_char;
665  BitBlock NameScan;
666  BitBlock Digit;
667  BitBlock Hex;
668  BitBlock WS;
669};
670
671  struct Scope1 {
672  BitBlock RefStart;
673  BitBlock LAngle;
674  BitBlock Hyphen;
675  BitBlock QMark;
676  BitBlock RBracket;
677};
678
679  struct Marker {
680  BitBlock LAngle_scope;
681  BitBlock Ref_opener;
682  BitBlock CD_closer;
683};
684
685  struct CtCDPI_Callouts {
686  BitBlock CD_end;
687  BitBlock Ct_starts;
688  BitBlock Ct_ends;
689  BitBlock CD_starts;
690  BitBlock CD_ends;
691  BitBlock PI_starts;
692  BitBlock PI_name_starts;
693  BitBlock PI_name_ends;
694  BitBlock PI_ends;
695  BitBlock CtCDPI_mask;
696};
697
698  struct Ref_Callouts {
699  BitBlock GenRef_starts;
700  BitBlock GenRef_ends;
701  BitBlock DecRef_starts;
702  BitBlock DecRef_ends;
703  BitBlock HexRef_starts;
704  BitBlock HexRef_ends;
705};
706
707  struct Hash_data {
708  BitBlock Hash_value;
709};
710
711  struct Tag_Callouts {
712  BitBlock ElemName_starts;
713  BitBlock ElemName_ends;
714  BitBlock ElemName_ends_1;
715  BitBlock ElemName_ends_2;
716  BitBlock ElemName_ends_3;
717  BitBlock ElemName_ends_4;
718  BitBlock ElemName_ends_5;
719  BitBlock ElemName_ends_6;
720  BitBlock ElemName_ends_7;
721  BitBlock ElemName_ends_8;
722  BitBlock ElemName_ends_9;
723  BitBlock ElemName_ends_10;
724  BitBlock ElemName_ends_11;
725  BitBlock ElemName_ends_12;
726  BitBlock ElemName_ends_13;
727  BitBlock ElemName_ends_14;
728  BitBlock ElemName_ends_15;
729  BitBlock ElemName_ends_16;
730  BitBlock ElemName_ends_17_and_longer;
731  BitBlock AttName_starts;
732  BitBlock AttName_ends;
733  BitBlock AttVal_starts;
734  BitBlock AttVal_ends;
735  BitBlock AttVal_spans;
736  BitBlock EmptyTag_marks;
737  BitBlock EndTag_marks;
738  BitBlock Tag_closing;
739};
740
741  struct Basis_bits {
742  BitBlock bit_0;
743  BitBlock bit_1;
744  BitBlock bit_2;
745  BitBlock bit_3;
746  BitBlock bit_4;
747  BitBlock bit_5;
748  BitBlock bit_6;
749  BitBlock bit_7;
750};
751
752  struct Check_streams {
753  BitBlock misc_mask;
754  BitBlock non_ascii_name_starts;
755  BitBlock non_ascii_names;
756  BitBlock tag_marks;
757  BitBlock name_follows;
758  BitBlock att_refs;
759};
760
761  struct Xml_names {
762  BitBlock namespace_error;
763};
764
765  struct Elem {
766  BitBlock purchaseOrder;
767  BitBlock shipTo;
768  BitBlock name;
769  BitBlock street;
770  BitBlock city;
771  BitBlock state;
772  BitBlock zip;
773  BitBlock billTo;
774  BitBlock comment;
775  BitBlock items;
776  BitBlock item;
777  BitBlock productName;
778  BitBlock quantity;
779  BitBlock USPrice;
780  BitBlock shipDate;
781};
782
783  struct Parse_refs {
784  Parse_refs() { 
785 }
786  IDISA_INLINE void do_block(Lex & lex, Marker & marker, Ref_Callouts & ref_Callouts) {
787                BitBlock ref_error, Ref_scope, NumRef2, NumRef3, HexRef3, ref_error1;
788                BitBlock ref_error2, ref_ends, ref_error3;
789
790
791
792
793        ref_Callouts.GenRef_starts = simd<1>::constant<0>();
794        ref_Callouts.GenRef_ends = simd<1>::constant<0>();
795        ref_Callouts.DecRef_starts = simd<1>::constant<0>();
796        ref_Callouts.DecRef_ends = simd<1>::constant<0>();
797        ref_Callouts.HexRef_starts = simd<1>::constant<0>();
798        ref_Callouts.HexRef_ends = simd<1>::constant<0>();
799        ref_error = simd<1>::constant<0>();
800        if ((bitblock::any(marker.Ref_opener) || carryQ.CarryTest(0, 6))) {
801          carryQ.cq[0] = bitblock::srli<127>(pablo_blk_Advance(marker.Ref_opener, carryQ.get_carry_in(0), Ref_scope));
802          NumRef2 = simd_and(Ref_scope, lex.Hash);
803          ref_Callouts.GenRef_starts = simd_andc(Ref_scope, lex.Hash);
804          carryQ.cq[1] = bitblock::srli<127>(pablo_blk_Advance(NumRef2, carryQ.get_carry_in(1), NumRef3));
805          HexRef3 = simd_and(NumRef3, lex.x);
806          ref_Callouts.DecRef_starts = simd_andc(NumRef3, lex.x);
807          carryQ.cq[2] = bitblock::srli<127>(pablo_blk_Advance(HexRef3, carryQ.get_carry_in(2), ref_Callouts.HexRef_starts));
808          carryQ.cq[3] = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.GenRef_starts, lex.NameScan, carryQ.get_carry_in(3), ref_Callouts.GenRef_ends));
809          carryQ.cq[4] = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.DecRef_starts, lex.Digit, carryQ.get_carry_in(4), ref_Callouts.DecRef_ends));
810          carryQ.cq[5] = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.HexRef_starts, lex.Hex, carryQ.get_carry_in(5), ref_Callouts.HexRef_ends));
811          ref_error1 = simd_andc(ref_Callouts.DecRef_starts, lex.Digit);
812          ref_error2 = simd_andc(ref_Callouts.HexRef_starts, lex.Hex);
813          ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
814          ref_error3 = simd_andc(ref_ends, lex.Semicolon);
815          if (bitblock::any(simd_or(simd_or(ref_error1, ref_error2), ref_error3))) {
816            assert_0_error("Reference error found", simd_or(simd_or(ref_error1, ref_error2), ref_error3));
817          }
818        }
819        else {
820          carryQ.CarryDequeueEnqueue(0, 6);
821        }
822        carryQ.CarryQ_Adjust(6);
823  }
824  void do_final_block(Lex & lex, Marker & marker, Ref_Callouts & ref_Callouts, BitBlock EOF_mask) {
825                BitBlock ref_error, Ref_scope, NumRef2, NumRef3, HexRef3, ref_error1;
826                BitBlock ref_error2, ref_ends, ref_error3;
827
828
829
830
831        ref_Callouts.GenRef_starts = simd<1>::constant<0>();
832        ref_Callouts.GenRef_ends = simd<1>::constant<0>();
833        ref_Callouts.DecRef_starts = simd<1>::constant<0>();
834        ref_Callouts.DecRef_ends = simd<1>::constant<0>();
835        ref_Callouts.HexRef_starts = simd<1>::constant<0>();
836        ref_Callouts.HexRef_ends = simd<1>::constant<0>();
837        ref_error = simd<1>::constant<0>();
838        if ((bitblock::any(marker.Ref_opener) || carryQ.CarryTest(0, 6))) {
839          carryQ.cq[0] = bitblock::srli<127>(pablo_blk_Advance(marker.Ref_opener, carryQ.get_carry_in(0), Ref_scope));
840          NumRef2 = simd_and(Ref_scope, lex.Hash);
841          ref_Callouts.GenRef_starts = simd_andc(Ref_scope, lex.Hash);
842          carryQ.cq[1] = bitblock::srli<127>(pablo_blk_Advance(NumRef2, carryQ.get_carry_in(1), NumRef3));
843          HexRef3 = simd_and(NumRef3, lex.x);
844          ref_Callouts.DecRef_starts = simd_andc(NumRef3, lex.x);
845          carryQ.cq[2] = bitblock::srli<127>(pablo_blk_Advance(HexRef3, carryQ.get_carry_in(2), ref_Callouts.HexRef_starts));
846          carryQ.cq[3] = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.GenRef_starts, lex.NameScan, carryQ.get_carry_in(3), ref_Callouts.GenRef_ends));
847          carryQ.cq[4] = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.DecRef_starts, lex.Digit, carryQ.get_carry_in(4), ref_Callouts.DecRef_ends));
848          carryQ.cq[5] = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.HexRef_starts, lex.Hex, carryQ.get_carry_in(5), ref_Callouts.HexRef_ends));
849          ref_error1 = simd_andc(ref_Callouts.DecRef_starts, lex.Digit);
850          ref_error2 = simd_andc(ref_Callouts.HexRef_starts, lex.Hex);
851          ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
852          ref_error3 = simd_andc(ref_ends, lex.Semicolon);
853          if (bitblock::any(simd_or(simd_or(ref_error1, ref_error2), ref_error3))) {
854            assert_0_error("Reference error found", simd_or(simd_or(ref_error1, ref_error2), ref_error3));
855          }
856        }
857        else {
858          carryQ.CarryDequeueEnqueue(0, 6);
859        }
860  }
861  CarryArray<6, 0> carryQ;
862  };
863
864  struct Validate_Elem_Vec {
865 
866  IDISA_INLINE void do_block(Elem & elem, Basis_bits & basis_bits) {
867                BitBlock temp1, temp2, temp3, temp4, temp5, temp6, temp7, temp8, temp9, temp10;
868                BitBlock temp11, temp12, temp13, temp14, temp15, temp16, temp17, temp18;
869                BitBlock temp19, temp20, temp21, temp22, temp23, temp24, temp25, temp26;
870
871
872
873
874        temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
875        temp2 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
876        temp3 = simd_or(temp1, temp2);
877        temp4 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
878        temp5 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
879        temp6 = simd_andc(temp5, temp4);
880        elem.purchaseOrder = simd_andc(temp6, temp3);
881        temp7 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
882        temp8 = simd_andc(temp7, temp4);
883        elem.shipTo = simd_andc(temp8, temp3);
884        temp9 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
885        temp10 = simd_andc(temp9, temp4);
886        elem.name = simd_andc(temp10, temp3);
887        temp11 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
888        temp12 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
889        temp13 = simd_andc(temp11, temp12);
890        elem.street = simd_andc(temp13, temp3);
891        temp14 = simd_and(temp11, temp5);
892        elem.city = simd_andc(temp14, temp3);
893        temp15 = simd_and(temp11, temp7);
894        elem.state = simd_andc(temp15, temp3);
895        temp16 = simd_and(temp11, temp9);
896        elem.zip = simd_andc(temp16, temp3);
897        temp17 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
898        temp18 = simd_andc(temp17, temp12);
899        elem.billTo = simd_andc(temp18, temp3);
900        temp19 = simd_and(temp17, temp5);
901        elem.comment = simd_andc(temp19, temp3);
902        temp20 = simd_and(temp17, temp7);
903        elem.items = simd_andc(temp20, temp3);
904        temp21 = simd_and(temp17, temp9);
905        elem.item = simd_andc(temp21, temp3);
906        temp22 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
907        temp23 = simd_andc(temp22, temp12);
908        elem.productName = simd_andc(temp23, temp3);
909        temp24 = simd_and(temp22, temp5);
910        elem.quantity = simd_andc(temp24, temp3);
911        temp25 = simd_and(temp22, temp7);
912        elem.USPrice = simd_andc(temp25, temp3);
913        temp26 = simd_and(temp22, temp9);
914        elem.shipDate = simd_andc(temp26, temp3);
915  }
916  void do_final_block(Elem & elem, Basis_bits & basis_bits, BitBlock EOF_mask) {
917                BitBlock temp1, temp2, temp3, temp4, temp5, temp6, temp7, temp8, temp9, temp10;
918                BitBlock temp11, temp12, temp13, temp14, temp15, temp16, temp17, temp18;
919                BitBlock temp19, temp20, temp21, temp22, temp23, temp24, temp25, temp26;
920
921
922
923
924        temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
925        temp2 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
926        temp3 = simd_or(temp1, temp2);
927        temp4 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
928        temp5 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
929        temp6 = simd_andc(temp5, temp4);
930        elem.purchaseOrder = simd_andc(temp6, temp3);
931        temp7 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
932        temp8 = simd_andc(temp7, temp4);
933        elem.shipTo = simd_andc(temp8, temp3);
934        temp9 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
935        temp10 = simd_andc(temp9, temp4);
936        elem.name = simd_andc(temp10, temp3);
937        temp11 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
938        temp12 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
939        temp13 = simd_andc(temp11, temp12);
940        elem.street = simd_andc(temp13, temp3);
941        temp14 = simd_and(temp11, temp5);
942        elem.city = simd_andc(temp14, temp3);
943        temp15 = simd_and(temp11, temp7);
944        elem.state = simd_andc(temp15, temp3);
945        temp16 = simd_and(temp11, temp9);
946        elem.zip = simd_andc(temp16, temp3);
947        temp17 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
948        temp18 = simd_andc(temp17, temp12);
949        elem.billTo = simd_andc(temp18, temp3);
950        temp19 = simd_and(temp17, temp5);
951        elem.comment = simd_andc(temp19, temp3);
952        temp20 = simd_and(temp17, temp7);
953        elem.items = simd_andc(temp20, temp3);
954        temp21 = simd_and(temp17, temp9);
955        elem.item = simd_andc(temp21, temp3);
956        temp22 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
957        temp23 = simd_andc(temp22, temp12);
958        elem.productName = simd_andc(temp23, temp3);
959        temp24 = simd_and(temp22, temp5);
960        elem.quantity = simd_andc(temp24, temp3);
961        temp25 = simd_and(temp22, temp7);
962        elem.USPrice = simd_andc(temp25, temp3);
963        temp26 = simd_and(temp22, temp9);
964        elem.shipDate = simd_andc(temp26, temp3);
965  }
966 
967  };
968
969  struct Parse_tags {
970  Parse_tags() { 
971 }
972  IDISA_INLINE void do_block(Lex & lex, Marker & marker, Tag_Callouts & tag_Callouts) {
973                BitBlock EqExpected, AttListEnd, DQuoteDelim, SQuoteDelim, AttListDelim;
974                BitBlock ParseError, AfterWS, AttNameStart, AttNameFollow, AttValPos;
975                BitBlock DQuoteAttVal, SQuoteAttVal, DQuoteAttEnd, SQuoteAttEnd, AttValEnd;
976                BitBlock AttValFollow, STagEnds, EndTagEnds;
977
978
979
980
981        EqExpected = simd<1>::constant<0>();
982        AttListEnd = simd<1>::constant<0>();
983        DQuoteDelim = simd_or(lex.DQuote, lex.LAngle);
984        SQuoteDelim = simd_or(lex.SQuote, lex.LAngle);
985        AttListDelim = simd_or(lex.Slash, lex.RAngle);
986        tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope, lex.Slash);
987        tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope, lex.Slash);
988        carryQ.cq[0] = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_starts, lex.NameScan, carryQ.get_carry_in(0), tag_Callouts.ElemName_ends));
989        ParseError = simd_and(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
990        tag_Callouts.AttName_starts = simd<1>::constant<0>();
991        tag_Callouts.AttName_ends = simd<1>::constant<0>();
992        tag_Callouts.AttVal_starts = simd<1>::constant<0>();
993        tag_Callouts.AttVal_ends = simd<1>::constant<0>();
994        if ((bitblock::any(simd_and(tag_Callouts.ElemName_ends, lex.WS)) || carryQ.CarryTest(1, 8))) {
995          carryQ.cq[1] = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_ends, lex.WS, carryQ.get_carry_in(1), AfterWS));
996          AttListEnd = simd_and(AfterWS, AttListDelim);
997          AttNameStart = simd_andc(AfterWS, AttListDelim);
998          if ((bitblock::any(AttNameStart) || carryQ.CarryTest(2, 7))) {
999            ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
1000            tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
1001            carryQ.cq[2] = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart, lex.NameScan, carryQ.get_carry_in(2), AttNameFollow));
1002            tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
1003            if ((bitblock::any(simd_and(AttNameFollow, lex.WS)) || carryQ.CarryTest(3, 1))) {
1004              carryQ.cq[3] = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow, lex.WS, carryQ.get_carry_in(3), EqExpected));
1005            }
1006            else {
1007              EqExpected = AttNameFollow;
1008              carryQ.CarryDequeueEnqueue(3, 1);
1009            }
1010            ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
1011            carryQ.cq[4] = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected, lex.WS, carryQ.get_carry_in(4), AttValPos));
1012            tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
1013            DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
1014            SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
1015            carryQ.cq[5] = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal, simd_not(DQuoteDelim), carryQ.get_carry_in(5), DQuoteAttEnd));
1016            carryQ.cq[6] = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal, simd_not(SQuoteDelim), carryQ.get_carry_in(6), SQuoteAttEnd));
1017            AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
1018            ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
1019            carryQ.cq[7] = bitblock::srli<127>(pablo_blk_Advance(AttValEnd, carryQ.get_carry_in(7), AttValFollow));
1020            tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
1021            if ((bitblock::any(simd_and(AttValFollow, lex.WS)) || carryQ.CarryTest(8, 1))) {
1022              carryQ.cq[8] = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow, lex.WS, carryQ.get_carry_in(8), AfterWS));
1023              AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
1024              AttNameStart = simd_andc(AfterWS, AttListDelim);
1025            }
1026            else {
1027              AttListEnd = simd_or(AttListEnd, simd_and(AttValFollow, AttListDelim));
1028              AttNameStart = simd_andc(AttValFollow, AttListDelim);
1029              carryQ.CarryDequeueEnqueue(8, 1);
1030            }
1031            ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
1032            while (bitblock::any(AttNameStart)) {
1033              LocalCarryDeclare(subcarryQ, 7);
1034              ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
1035              tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
1036              subcarryQ.cq[0] = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart, lex.NameScan, simd<1>::constant<0>(), AttNameFollow));
1037              tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
1038              if (bitblock::any(simd_and(AttNameFollow, lex.WS))) {
1039                subcarryQ.cq[1] = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow, lex.WS, simd<1>::constant<0>(), EqExpected));
1040              }
1041              else {
1042                EqExpected = AttNameFollow;
1043                subcarryQ.CarryDequeueEnqueue(3, 1);
1044              }
1045              ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
1046              subcarryQ.cq[2] = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected, lex.WS, simd<1>::constant<0>(), AttValPos));
1047              tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
1048              DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
1049              SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
1050              subcarryQ.cq[3] = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal, simd_not(DQuoteDelim), simd<1>::constant<0>(), DQuoteAttEnd));
1051              subcarryQ.cq[4] = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal, simd_not(SQuoteDelim), simd<1>::constant<0>(), SQuoteAttEnd));
1052              AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
1053              ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
1054              subcarryQ.cq[5] = bitblock::srli<127>(pablo_blk_Advance(AttValEnd, simd<1>::constant<0>(), AttValFollow));
1055              tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
1056              if (bitblock::any(simd_and(AttValFollow, lex.WS))) {
1057                subcarryQ.cq[6] = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow, lex.WS, simd<1>::constant<0>(), AfterWS));
1058                AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
1059                AttNameStart = simd_andc(AfterWS, AttListDelim);
1060              }
1061              else {
1062                AttListEnd = simd_or(AttListEnd, simd_and(AttValFollow, AttListDelim));
1063                AttNameStart = simd_andc(AttValFollow, AttListDelim);
1064                subcarryQ.CarryDequeueEnqueue(8, 1);
1065              }
1066              ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
1067              carryQ.CarryCombine(subcarryQ.cq, 2, 7);
1068            }
1069          }
1070          else {
1071            carryQ.CarryDequeueEnqueue(2, 7);
1072          }
1073        }
1074        else {
1075          AttListEnd = simd_and(tag_Callouts.ElemName_ends, AttListDelim);
1076          ParseError = simd_or(ParseError, simd_andc(tag_Callouts.ElemName_ends, AttListDelim));
1077          carryQ.CarryDequeueEnqueue(1, 8);
1078        }
1079        STagEnds = simd_and(AttListEnd, lex.RAngle);
1080        carryQ.cq[9] = bitblock::srli<127>(pablo_blk_Advance(simd_and(AttListEnd, lex.Slash), carryQ.get_carry_in(9), tag_Callouts.EmptyTag_marks));
1081        ParseError = simd_or(ParseError, simd_andc(tag_Callouts.EmptyTag_marks, lex.RAngle));
1082        carryQ.cq[10] = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks, lex.NameScan, carryQ.get_carry_in(10), EndTagEnds));
1083        if ((bitblock::any(simd_and(EndTagEnds, lex.WS)) || carryQ.CarryTest(11, 1))) {
1084          carryQ.cq[11] = bitblock::srli<127>(pablo_blk_ScanThru(EndTagEnds, lex.WS, carryQ.get_carry_in(11), EndTagEnds));
1085        }
1086        else {
1087          carryQ.CarryDequeueEnqueue(11, 1);
1088        }
1089        ParseError = simd_or(ParseError, simd_andc(EndTagEnds, lex.RAngle));
1090        if (bitblock::any(ParseError)) {
1091          assert_0_error("Tag parsing error found", ParseError);
1092        }
1093        carryQ.cq[12] = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carryQ.get_carry_in(12), tag_Callouts.AttVal_spans));
1094        tag_Callouts.Tag_closing = simd_or(tag_Callouts.EmptyTag_marks, tag_Callouts.EndTag_marks);
1095        carryQ.CarryQ_Adjust(13);
1096  }
1097  void do_final_block(Lex & lex, Marker & marker, Tag_Callouts & tag_Callouts, BitBlock EOF_mask) {
1098                BitBlock EqExpected, AttListEnd, DQuoteDelim, SQuoteDelim, AttListDelim;
1099                BitBlock ParseError, AfterWS, AttNameStart, AttNameFollow, AttValPos;
1100                BitBlock DQuoteAttVal, SQuoteAttVal, DQuoteAttEnd, SQuoteAttEnd, AttValEnd;
1101                BitBlock AttValFollow, STagEnds, EndTagEnds;
1102
1103
1104
1105
1106        EqExpected = simd<1>::constant<0>();
1107        AttListEnd = simd<1>::constant<0>();
1108        DQuoteDelim = simd_or(lex.DQuote, lex.LAngle);
1109        SQuoteDelim = simd_or(lex.SQuote, lex.LAngle);
1110        AttListDelim = simd_or(lex.Slash, lex.RAngle);
1111        tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope, lex.Slash);
1112        tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope, lex.Slash);
1113        carryQ.cq[0] = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_starts, lex.NameScan, carryQ.get_carry_in(0), tag_Callouts.ElemName_ends));
1114        ParseError = simd_and(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
1115        tag_Callouts.AttName_starts = simd<1>::constant<0>();
1116        tag_Callouts.AttName_ends = simd<1>::constant<0>();
1117        tag_Callouts.AttVal_starts = simd<1>::constant<0>();
1118        tag_Callouts.AttVal_ends = simd<1>::constant<0>();
1119        if ((bitblock::any(simd_and(tag_Callouts.ElemName_ends, lex.WS)) || carryQ.CarryTest(1, 8))) {
1120          carryQ.cq[1] = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_ends, lex.WS, carryQ.get_carry_in(1), AfterWS));
1121          AttListEnd = simd_and(AfterWS, AttListDelim);
1122          AttNameStart = simd_andc(AfterWS, AttListDelim);
1123          if ((bitblock::any(simd_and(AttNameStart, EOF_mask)) || carryQ.CarryTest(2, 7))) {
1124            ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
1125            tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
1126            carryQ.cq[2] = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart, lex.NameScan, carryQ.get_carry_in(2), AttNameFollow));
1127            tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
1128            if ((bitblock::any(simd_and(AttNameFollow, lex.WS)) || carryQ.CarryTest(3, 1))) {
1129              carryQ.cq[3] = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow, lex.WS, carryQ.get_carry_in(3), EqExpected));
1130            }
1131            else {
1132              EqExpected = AttNameFollow;
1133              carryQ.CarryDequeueEnqueue(3, 1);
1134            }
1135            ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
1136            carryQ.cq[4] = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected, lex.WS, carryQ.get_carry_in(4), AttValPos));
1137            tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
1138            DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
1139            SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
1140            carryQ.cq[5] = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal, simd_andc(EOF_mask, DQuoteDelim), carryQ.get_carry_in(5), DQuoteAttEnd));
1141            carryQ.cq[6] = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal, simd_andc(EOF_mask, SQuoteDelim), carryQ.get_carry_in(6), SQuoteAttEnd));
1142            AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
1143            ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
1144            carryQ.cq[7] = bitblock::srli<127>(pablo_blk_Advance(AttValEnd, carryQ.get_carry_in(7), AttValFollow));
1145            tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
1146            if ((bitblock::any(simd_and(AttValFollow, lex.WS)) || carryQ.CarryTest(8, 1))) {
1147              carryQ.cq[8] = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow, lex.WS, carryQ.get_carry_in(8), AfterWS));
1148              AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
1149              AttNameStart = simd_andc(AfterWS, AttListDelim);
1150            }
1151            else {
1152              AttListEnd = simd_or(AttListEnd, simd_and(AttValFollow, AttListDelim));
1153              AttNameStart = simd_andc(AttValFollow, AttListDelim);
1154              carryQ.CarryDequeueEnqueue(8, 1);
1155            }
1156            ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
1157            while (bitblock::any(simd_and(AttNameStart, EOF_mask))) {
1158              LocalCarryDeclare(subcarryQ, 7);
1159              ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
1160              tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
1161              subcarryQ.cq[0] = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart, lex.NameScan, simd<1>::constant<0>(), AttNameFollow));
1162              tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
1163              if (bitblock::any(simd_and(AttNameFollow, lex.WS))) {
1164                subcarryQ.cq[1] = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow, lex.WS, simd<1>::constant<0>(), EqExpected));
1165              }
1166              else {
1167                EqExpected = AttNameFollow;
1168                subcarryQ.CarryDequeueEnqueue(3, 1);
1169              }
1170              ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
1171              subcarryQ.cq[2] = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected, lex.WS, simd<1>::constant<0>(), AttValPos));
1172              tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
1173              DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
1174              SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
1175              subcarryQ.cq[3] = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal, simd_andc(EOF_mask, DQuoteDelim), simd<1>::constant<0>(), DQuoteAttEnd));
1176              subcarryQ.cq[4] = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal, simd_andc(EOF_mask, SQuoteDelim), simd<1>::constant<0>(), SQuoteAttEnd));
1177              AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
1178              ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
1179              subcarryQ.cq[5] = bitblock::srli<127>(pablo_blk_Advance(AttValEnd, simd<1>::constant<0>(), AttValFollow));
1180              tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
1181              if (bitblock::any(simd_and(AttValFollow, lex.WS))) {
1182                subcarryQ.cq[6] = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow, lex.WS, simd<1>::constant<0>(), AfterWS));
1183                AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
1184                AttNameStart = simd_andc(AfterWS, AttListDelim);
1185              }
1186              else {
1187                AttListEnd = simd_or(AttListEnd, simd_and(AttValFollow, AttListDelim));
1188                AttNameStart = simd_andc(AttValFollow, AttListDelim);
1189                subcarryQ.CarryDequeueEnqueue(8, 1);
1190              }
1191              ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
1192              carryQ.CarryCombine(subcarryQ.cq, 2, 7);
1193            }
1194          }
1195          else {
1196            carryQ.CarryDequeueEnqueue(2, 7);
1197          }
1198        }
1199        else {
1200          AttListEnd = simd_and(tag_Callouts.ElemName_ends, AttListDelim);
1201          ParseError = simd_or(ParseError, simd_andc(tag_Callouts.ElemName_ends, AttListDelim));
1202          carryQ.CarryDequeueEnqueue(1, 8);
1203        }
1204        STagEnds = simd_and(AttListEnd, lex.RAngle);
1205        carryQ.cq[9] = bitblock::srli<127>(pablo_blk_Advance(simd_and(AttListEnd, lex.Slash), carryQ.get_carry_in(9), tag_Callouts.EmptyTag_marks));
1206        ParseError = simd_or(ParseError, simd_andc(tag_Callouts.EmptyTag_marks, lex.RAngle));
1207        carryQ.cq[10] = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks, lex.NameScan, carryQ.get_carry_in(10), EndTagEnds));
1208        if ((bitblock::any(simd_and(EndTagEnds, lex.WS)) || carryQ.CarryTest(11, 1))) {
1209          carryQ.cq[11] = bitblock::srli<127>(pablo_blk_ScanThru(EndTagEnds, lex.WS, carryQ.get_carry_in(11), EndTagEnds));
1210        }
1211        else {
1212          carryQ.CarryDequeueEnqueue(11, 1);
1213        }
1214        ParseError = simd_or(ParseError, simd_andc(EndTagEnds, lex.RAngle));
1215        if (bitblock::any(ParseError)) {
1216          assert_0_error("Tag parsing error found", ParseError);
1217        }
1218        carryQ.cq[12] = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carryQ.get_carry_in(12), tag_Callouts.AttVal_spans));
1219        tag_Callouts.Tag_closing = simd_or(tag_Callouts.EmptyTag_marks, tag_Callouts.EndTag_marks);
1220  }
1221  CarryArray<13, 0> carryQ;
1222  };
1223
1224  struct Classify_bytes_Validate_utf8 {
1225  Classify_bytes_Validate_utf8() { 
1226 }
1227  IDISA_INLINE void do_block(Basis_bits & basis_bits, Lex & lex, U8 & u8) {
1228                BitBlock temp1, temp2, temp3, temp4, temp5, temp6, temp7, temp8, temp9, temp10;
1229                BitBlock temp11, temp12, temp13, temp14, temp15, temp16, temp17, temp18;
1230                BitBlock temp19, temp20, temp21, temp22, temp23, temp24, temp25, temp26;
1231                BitBlock temp27, temp28, temp29, temp30, temp31, temp32, temp33, temp34;
1232                BitBlock temp35, temp36, temp37, temp38, temp39, temp40, temp41, temp42;
1233                BitBlock temp43, temp44, temp45, temp46, temp47, temp48, x00_x1F, temp49;
1234                BitBlock temp50, temp51, temp52, temp53, temp54, temp55, temp56, temp57;
1235                BitBlock temp58, temp59, temp60, temp61, temp62, temp63, temp64, temp65;
1236                BitBlock lex_error, u8_error, u8_FFFE_FFFF, u8anyscope, temp66, temp67, temp68;
1237                BitBlock temp69, temp70, temp71, xE0, xED, xF0, temp72, xF4, xEF, temp73;
1238                BitBlock u8lastscope, u8error1, u8error2, u8error3, u8error4, EF_BF_pending;
1239                BitBlock u8mismatch;
1240
1241
1242
1243
1244        temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
1245        temp2 = simd_andc(basis_bits.bit_2, basis_bits.bit_3);
1246        temp3 = simd_andc(temp2, temp1);
1247        temp4 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
1248        temp5 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
1249        temp6 = simd_and(temp4, temp5);
1250        lex.RefStart = simd_and(temp3, temp6);
1251        temp7 = simd_and(basis_bits.bit_2, basis_bits.bit_3);
1252        temp8 = simd_andc(temp7, temp1);
1253        temp9 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
1254        temp10 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
1255        temp11 = simd_and(temp9, temp10);
1256        lex.Semicolon = simd_and(temp8, temp11);
1257        temp12 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
1258        temp13 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
1259        temp14 = simd_andc(temp12, temp13);
1260        lex.LAngle = simd_and(temp8, temp14);
1261        temp15 = simd_and(temp12, temp5);
1262        lex.RAngle = simd_and(temp8, temp15);
1263        temp16 = simd_andc(basis_bits.bit_1, basis_bits.bit_0);
1264        temp17 = simd_andc(basis_bits.bit_3, basis_bits.bit_2);
1265        temp18 = simd_and(temp16, temp17);
1266        lex.LBracket = simd_and(temp18, temp11);
1267        temp19 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
1268        temp20 = simd_and(temp12, temp19);
1269        lex.RBracket = simd_and(temp18, temp20);
1270        temp21 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
1271        temp22 = simd_andc(temp19, temp21);
1272        lex.Exclam = simd_and(temp3, temp22);
1273        temp23 = simd_and(temp12, temp10);
1274        lex.QMark = simd_and(temp8, temp23);
1275        lex.Hyphen = simd_and(temp3, temp20);
1276        lex.Equals = simd_and(temp8, temp20);
1277        temp24 = simd_and(temp4, temp10);
1278        lex.SQuote = simd_and(temp3, temp24);
1279        temp25 = simd_andc(temp5, temp21);
1280        lex.DQuote = simd_and(temp3, temp25);
1281        lex.Slash = simd_and(temp3, temp23);
1282        temp26 = simd_andc(temp10, temp21);
1283        lex.Hash = simd_and(temp3, temp26);
1284        temp27 = simd_and(temp16, temp7);
1285        temp28 = simd_andc(temp9, temp13);
1286        lex.x = simd_and(temp27, temp28);
1287        temp29 = simd_and(temp9, temp5);
1288        lex.Colon = simd_and(temp8, temp29);
1289        temp30 = simd_and(temp18, temp23);
1290        temp31 = simd_or(temp30, lex.Colon);
1291        temp32 = simd_andc(temp16, basis_bits.bit_2);
1292        temp33 = simd_or(basis_bits.bit_5, temp10);
1293        temp34 = simd_and(basis_bits.bit_4, temp33);
1294        temp35 = simd_not(temp34);
1295        temp36 = simd_or(temp21, temp13);
1296        temp37 = simd_or(simd_and(basis_bits.bit_3, temp35), simd_andc(temp36, basis_bits.bit_3));
1297        temp38 = simd_and(temp32, temp37);
1298        temp39 = simd_or(temp31, temp38);
1299        temp40 = simd_and(temp16, basis_bits.bit_2);
1300        temp41 = simd_and(temp40, temp37);
1301        lex.ASCII_name_start = simd_or(temp39, temp41);
1302        temp42 = simd_or(temp30, lex.Hyphen);
1303        temp43 = simd_and(temp3, temp15);
1304        temp44 = simd_or(temp42, temp43);
1305        temp45 = simd_andc(temp8, temp34);
1306        temp46 = simd_or(temp44, temp45);
1307        temp47 = simd_or(temp46, temp38);
1308        lex.ASCII_name_char = simd_or(temp47, temp41);
1309        lex.NameScan = simd_or(lex.ASCII_name_char, basis_bits.bit_0);
1310        temp48 = simd_or(temp1, basis_bits.bit_2);
1311        x00_x1F = simd_not(temp48);
1312        temp49 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
1313        temp50 = simd_or(temp1, temp49);
1314        lex.CR = simd_andc(temp20, temp50);
1315        lex.LF = simd_andc(temp29, temp50);
1316        temp51 = simd_and(temp9, temp19);
1317        lex.HT = simd_andc(temp51, temp50);
1318        lex.SP = simd_andc(temp3, temp36);
1319        temp52 = simd_or(temp20, temp29);
1320        temp53 = simd_or(temp52, temp51);
1321        temp54 = simd_andc(temp53, temp50);
1322        lex.WS = simd_or(temp54, lex.SP);
1323        temp55 = simd_or(basis_bits.bit_5, basis_bits.bit_6);
1324        temp56 = simd_and(basis_bits.bit_4, temp55);
1325        lex.Digit = simd_andc(temp8, temp56);
1326        temp57 = simd_andc(temp16, temp49);
1327        temp58 = simd_andc(temp57, basis_bits.bit_4);
1328        temp59 = simd_not(temp10);
1329        temp60 = simd_or(simd_and(basis_bits.bit_5, temp59), simd_andc(temp13, basis_bits.bit_5));
1330        temp61 = simd_and(temp58, temp60);
1331        temp62 = simd_or(lex.Digit, temp61);
1332        temp63 = simd_and(temp16, temp2);
1333        temp64 = simd_andc(temp63, basis_bits.bit_4);
1334        temp65 = simd_and(temp64, temp60);
1335        lex.Hex = simd_or(temp62, temp65);
1336        lex_error = simd_andc(x00_x1F, lex.WS);
1337        if (bitblock::any(simd_and(lex_error, EOF_mask))) {
1338          error_tracker.NoteError("Error: illegal character", lex_error);
1339        }
1340        u8.unibyte = simd_not(basis_bits.bit_0);
1341        u8.suffix = simd<1>::constant<0>();
1342        u8_error = simd<1>::constant<0>();
1343        u8_FFFE_FFFF = simd<1>::constant<0>();
1344        u8anyscope = simd<1>::constant<0>();
1345        if ((bitblock::any(basis_bits.bit_0) || carryQ.CarryTest(0, 12))) {
1346          u8.prefix = simd_and(basis_bits.bit_0, basis_bits.bit_1);
1347          u8.prefix2 = simd_andc(u8.prefix, basis_bits.bit_2);
1348          u8.prefix3 = simd_and(u8.prefix, temp2);
1349          u8.prefix4 = simd_and(u8.prefix, temp7);
1350          u8.suffix = simd_andc(basis_bits.bit_0, basis_bits.bit_1);
1351          temp66 = simd_andc(u8.prefix, temp49);
1352          temp67 = simd_or(temp21, basis_bits.bit_6);
1353          temp68 = simd_andc(temp66, temp67);
1354          temp69 = simd_and(basis_bits.bit_5, temp13);
1355          temp70 = simd_or(basis_bits.bit_4, temp69);
1356          temp71 = simd_and(u8.prefix4, temp70);
1357          u8.badprefix = simd_or(temp68, temp71);
1358          u8_error = u8.badprefix;
1359          carryQ.cq[0] = bitblock::srli<127>(pablo_blk_Advance(u8.prefix2, carryQ.get_carry_in(0), u8.scope22));
1360          u8anyscope = u8.scope22;
1361          if ((bitblock::any(simd_or(u8.prefix3, u8.prefix4)) || carryQ.CarryTest(1, 11))) {
1362            xE0 = simd_andc(u8.prefix3, temp36);
1363            xED = simd_and(u8.prefix3, temp20);
1364            xF0 = simd_andc(u8.prefix4, temp36);
1365            temp72 = simd_andc(temp4, temp13);
1366            xF4 = simd_and(u8.prefix4, temp72);
1367            u8.xA0_xBF = simd_and(u8.suffix, basis_bits.bit_2);
1368            u8.x80_x9F = simd_andc(u8.suffix, basis_bits.bit_2);
1369            u8.x90_xBF = simd_and(u8.suffix, temp49);
1370            u8.x80_x8F = simd_andc(u8.suffix, temp49);
1371            xEF = simd_and(u8.prefix3, temp23);
1372            temp73 = simd_and(u8.suffix, temp7);
1373            u8.xBF = simd_and(temp73, temp23);
1374            u8.xBE = simd_and(temp73, temp15);
1375            carryQ.cq[1] = bitblock::srli<127>(pablo_blk_Advance(xE0, carryQ.get_carry_in(1), u8.xE0_scope));
1376            carryQ.cq[2] = bitblock::srli<127>(pablo_blk_Advance(xED, carryQ.get_carry_in(2), u8.xED_scope));
1377            carryQ.cq[3] = bitblock::srli<127>(pablo_blk_Advance(xF0, carryQ.get_carry_in(3), u8.xF0_scope));
1378            carryQ.cq[4] = bitblock::srli<127>(pablo_blk_Advance(xF4, carryQ.get_carry_in(4), u8.xF4_scope));
1379            carryQ.cq[5] = bitblock::srli<127>(pablo_blk_Advance(xEF, carryQ.get_carry_in(5), u8.xEF_scope));
1380            carryQ.cq[6] = bitblock::srli<127>(pablo_blk_Advance(u8.prefix3, carryQ.get_carry_in(6), u8.scope32));
1381            carryQ.cq[7] = bitblock::srli<127>(pablo_blk_Advance(u8.scope32, carryQ.get_carry_in(7), u8.scope33));
1382            carryQ.cq[8] = bitblock::srli<127>(pablo_blk_Advance(u8.prefix4, carryQ.get_carry_in(8), u8.scope42));
1383            carryQ.cq[9] = bitblock::srli<127>(pablo_blk_Advance(u8.scope42, carryQ.get_carry_in(9), u8.scope43));
1384            carryQ.cq[10] = bitblock::srli<127>(pablo_blk_Advance(u8.scope43, carryQ.get_carry_in(10), u8.scope44));
1385            u8lastscope = simd_or(simd_or(u8.scope22, u8.scope33), u8.scope44);
1386            u8anyscope = simd_or(simd_or(simd_or(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
1387            u8error1 = simd_and(u8.xE0_scope, u8.x80_x9F);
1388            u8error2 = simd_and(u8.xED_scope, u8.xA0_xBF);
1389            u8error3 = simd_and(u8.xF0_scope, u8.x80_x8F);
1390            u8error4 = simd_and(u8.xF4_scope, u8.x90_xBF);
1391            u8_error = simd_or(u8_error, simd_or(simd_or(simd_or(u8error1, u8error2), u8error3), u8error4));
1392            carryQ.cq[11] = bitblock::srli<127>(pablo_blk_Advance(simd_and(u8.xEF_scope, u8.xBF), carryQ.get_carry_in(11), EF_BF_pending));
1393            u8_FFFE_FFFF = simd_and(EF_BF_pending, simd_or(u8.xBE, u8.xBF));
1394          }
1395          else {
1396            carryQ.CarryDequeueEnqueue(1, 11);
1397          }
1398          u8mismatch = simd_xor(u8anyscope, u8.suffix);
1399          u8_error = simd_or(u8_error, simd_or(u8mismatch, u8_FFFE_FFFF));
1400          if (bitblock::any(u8_error)) {
1401            error_tracker.NoteError("UTF-8 error found", u8_error);
1402          }
1403        }
1404        else {
1405          carryQ.CarryDequeueEnqueue(0, 12);
1406        }
1407        carryQ.CarryQ_Adjust(12);
1408  }
1409  void do_final_block(Basis_bits & basis_bits, Lex & lex, U8 & u8, BitBlock EOF_mask) {
1410                BitBlock temp1, temp2, temp3, temp4, temp5, temp6, temp7, temp8, temp9, temp10;
1411                BitBlock temp11, temp12, temp13, temp14, temp15, temp16, temp17, temp18;
1412                BitBlock temp19, temp20, temp21, temp22, temp23, temp24, temp25, temp26;
1413                BitBlock temp27, temp28, temp29, temp30, temp31, temp32, temp33, temp34;
1414                BitBlock temp35, temp36, temp37, temp38, temp39, temp40, temp41, temp42;
1415                BitBlock temp43, temp44, temp45, temp46, temp47, temp48, x00_x1F, temp49;
1416                BitBlock temp50, temp51, temp52, temp53, temp54, temp55, temp56, temp57;
1417                BitBlock temp58, temp59, temp60, temp61, temp62, temp63, temp64, temp65;
1418                BitBlock lex_error, u8_error, u8_FFFE_FFFF, u8anyscope, temp66, temp67, temp68;
1419                BitBlock temp69, temp70, temp71, xE0, xED, xF0, temp72, xF4, xEF, temp73;
1420                BitBlock u8lastscope, u8error1, u8error2, u8error3, u8error4, EF_BF_pending;
1421                BitBlock u8mismatch;
1422
1423
1424
1425
1426        temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
1427        temp2 = simd_andc(basis_bits.bit_2, basis_bits.bit_3);
1428        temp3 = simd_andc(temp2, temp1);
1429        temp4 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
1430        temp5 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
1431        temp6 = simd_and(temp4, temp5);
1432        lex.RefStart = simd_and(temp3, temp6);
1433        temp7 = simd_and(basis_bits.bit_2, basis_bits.bit_3);
1434        temp8 = simd_andc(temp7, temp1);
1435        temp9 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
1436        temp10 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
1437        temp11 = simd_and(temp9, temp10);
1438        lex.Semicolon = simd_and(temp8, temp11);
1439        temp12 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
1440        temp13 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
1441        temp14 = simd_andc(temp12, temp13);
1442        lex.LAngle = simd_and(temp8, temp14);
1443        temp15 = simd_and(temp12, temp5);
1444        lex.RAngle = simd_and(temp8, temp15);
1445        temp16 = simd_andc(basis_bits.bit_1, basis_bits.bit_0);
1446        temp17 = simd_andc(basis_bits.bit_3, basis_bits.bit_2);
1447        temp18 = simd_and(temp16, temp17);
1448        lex.LBracket = simd_and(temp18, temp11);
1449        temp19 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
1450        temp20 = simd_and(temp12, temp19);
1451        lex.RBracket = simd_and(temp18, temp20);
1452        temp21 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
1453        temp22 = simd_andc(temp19, temp21);
1454        lex.Exclam = simd_and(temp3, temp22);
1455        temp23 = simd_and(temp12, temp10);
1456        lex.QMark = simd_and(temp8, temp23);
1457        lex.Hyphen = simd_and(temp3, temp20);
1458        lex.Equals = simd_and(temp8, temp20);
1459        temp24 = simd_and(temp4, temp10);
1460        lex.SQuote = simd_and(temp3, temp24);
1461        temp25 = simd_andc(temp5, temp21);
1462        lex.DQuote = simd_and(temp3, temp25);
1463        lex.Slash = simd_and(temp3, temp23);
1464        temp26 = simd_andc(temp10, temp21);
1465        lex.Hash = simd_and(temp3, temp26);
1466        temp27 = simd_and(temp16, temp7);
1467        temp28 = simd_andc(temp9, temp13);
1468        lex.x = simd_and(temp27, temp28);
1469        temp29 = simd_and(temp9, temp5);
1470        lex.Colon = simd_and(temp8, temp29);
1471        temp30 = simd_and(temp18, temp23);
1472        temp31 = simd_or(temp30, lex.Colon);
1473        temp32 = simd_andc(temp16, basis_bits.bit_2);
1474        temp33 = simd_or(basis_bits.bit_5, temp10);
1475        temp34 = simd_and(basis_bits.bit_4, temp33);
1476        temp35 = simd_not(temp34);
1477        temp36 = simd_or(temp21, temp13);
1478        temp37 = simd_or(simd_and(basis_bits.bit_3, temp35), simd_andc(temp36, basis_bits.bit_3));
1479        temp38 = simd_and(temp32, temp37);
1480        temp39 = simd_or(temp31, temp38);
1481        temp40 = simd_and(temp16, basis_bits.bit_2);
1482        temp41 = simd_and(temp40, temp37);
1483        lex.ASCII_name_start = simd_or(temp39, temp41);
1484        temp42 = simd_or(temp30, lex.Hyphen);
1485        temp43 = simd_and(temp3, temp15);
1486        temp44 = simd_or(temp42, temp43);
1487        temp45 = simd_andc(temp8, temp34);
1488        temp46 = simd_or(temp44, temp45);
1489        temp47 = simd_or(temp46, temp38);
1490        lex.ASCII_name_char = simd_or(temp47, temp41);
1491        lex.NameScan = simd_or(lex.ASCII_name_char, basis_bits.bit_0);
1492        temp48 = simd_or(temp1, basis_bits.bit_2);
1493        x00_x1F = simd_not(temp48);
1494        temp49 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
1495        temp50 = simd_or(temp1, temp49);
1496        lex.CR = simd_andc(temp20, temp50);
1497        lex.LF = simd_andc(temp29, temp50);
1498        temp51 = simd_and(temp9, temp19);
1499        lex.HT = simd_andc(temp51, temp50);
1500        lex.SP = simd_andc(temp3, temp36);
1501        temp52 = simd_or(temp20, temp29);
1502        temp53 = simd_or(temp52, temp51);
1503        temp54 = simd_andc(temp53, temp50);
1504        lex.WS = simd_or(temp54, lex.SP);
1505        temp55 = simd_or(basis_bits.bit_5, basis_bits.bit_6);
1506        temp56 = simd_and(basis_bits.bit_4, temp55);
1507        lex.Digit = simd_andc(temp8, temp56);
1508        temp57 = simd_andc(temp16, temp49);
1509        temp58 = simd_andc(temp57, basis_bits.bit_4);
1510        temp59 = simd_not(temp10);
1511        temp60 = simd_or(simd_and(basis_bits.bit_5, temp59), simd_andc(temp13, basis_bits.bit_5));
1512        temp61 = simd_and(temp58, temp60);
1513        temp62 = simd_or(lex.Digit, temp61);
1514        temp63 = simd_and(temp16, temp2);
1515        temp64 = simd_andc(temp63, basis_bits.bit_4);
1516        temp65 = simd_and(temp64, temp60);
1517        lex.Hex = simd_or(temp62, temp65);
1518        lex_error = simd_andc(x00_x1F, lex.WS);
1519        if (bitblock::any(simd_and(lex_error, EOF_mask))) {
1520          error_tracker.NoteError("Error: illegal character", lex_error);
1521        }
1522        u8.unibyte = simd_not(basis_bits.bit_0);
1523        u8.suffix = simd<1>::constant<0>();
1524        u8_error = simd<1>::constant<0>();
1525        u8_FFFE_FFFF = simd<1>::constant<0>();
1526        u8anyscope = simd<1>::constant<0>();
1527        if ((bitblock::any(basis_bits.bit_0) || carryQ.CarryTest(0, 12))) {
1528          u8.prefix = simd_and(basis_bits.bit_0, basis_bits.bit_1);
1529          u8.prefix2 = simd_andc(u8.prefix, basis_bits.bit_2);
1530          u8.prefix3 = simd_and(u8.prefix, temp2);
1531          u8.prefix4 = simd_and(u8.prefix, temp7);
1532          u8.suffix = simd_andc(basis_bits.bit_0, basis_bits.bit_1);
1533          temp66 = simd_andc(u8.prefix, temp49);
1534          temp67 = simd_or(temp21, basis_bits.bit_6);
1535          temp68 = simd_andc(temp66, temp67);
1536          temp69 = simd_and(basis_bits.bit_5, temp13);
1537          temp70 = simd_or(basis_bits.bit_4, temp69);
1538          temp71 = simd_and(u8.prefix4, temp70);
1539          u8.badprefix = simd_or(temp68, temp71);
1540          u8_error = u8.badprefix;
1541          carryQ.cq[0] = bitblock::srli<127>(pablo_blk_Advance(u8.prefix2, carryQ.get_carry_in(0), u8.scope22));
1542          u8anyscope = u8.scope22;
1543          if ((bitblock::any(simd_or(u8.prefix3, u8.prefix4)) || carryQ.CarryTest(1, 11))) {
1544            xE0 = simd_andc(u8.prefix3, temp36);
1545            xED = simd_and(u8.prefix3, temp20);
1546            xF0 = simd_andc(u8.prefix4, temp36);
1547            temp72 = simd_andc(temp4, temp13);
1548            xF4 = simd_and(u8.prefix4, temp72);
1549            u8.xA0_xBF = simd_and(u8.suffix, basis_bits.bit_2);
1550            u8.x80_x9F = simd_andc(u8.suffix, basis_bits.bit_2);
1551            u8.x90_xBF = simd_and(u8.suffix, temp49);
1552            u8.x80_x8F = simd_andc(u8.suffix, temp49);
1553            xEF = simd_and(u8.prefix3, temp23);
1554            temp73 = simd_and(u8.suffix, temp7);
1555            u8.xBF = simd_and(temp73, temp23);
1556            u8.xBE = simd_and(temp73, temp15);
1557            carryQ.cq[1] = bitblock::srli<127>(pablo_blk_Advance(xE0, carryQ.get_carry_in(1), u8.xE0_scope));
1558            carryQ.cq[2] = bitblock::srli<127>(pablo_blk_Advance(xED, carryQ.get_carry_in(2), u8.xED_scope));
1559            carryQ.cq[3] = bitblock::srli<127>(pablo_blk_Advance(xF0, carryQ.get_carry_in(3), u8.xF0_scope));
1560            carryQ.cq[4] = bitblock::srli<127>(pablo_blk_Advance(xF4, carryQ.get_carry_in(4), u8.xF4_scope));
1561            carryQ.cq[5] = bitblock::srli<127>(pablo_blk_Advance(xEF, carryQ.get_carry_in(5), u8.xEF_scope));
1562            carryQ.cq[6] = bitblock::srli<127>(pablo_blk_Advance(u8.prefix3, carryQ.get_carry_in(6), u8.scope32));
1563            carryQ.cq[7] = bitblock::srli<127>(pablo_blk_Advance(u8.scope32, carryQ.get_carry_in(7), u8.scope33));
1564            carryQ.cq[8] = bitblock::srli<127>(pablo_blk_Advance(u8.prefix4, carryQ.get_carry_in(8), u8.scope42));
1565            carryQ.cq[9] = bitblock::srli<127>(pablo_blk_Advance(u8.scope42, carryQ.get_carry_in(9), u8.scope43));
1566            carryQ.cq[10] = bitblock::srli<127>(pablo_blk_Advance(u8.scope43, carryQ.get_carry_in(10), u8.scope44));
1567            u8lastscope = simd_or(simd_or(u8.scope22, u8.scope33), u8.scope44);
1568            u8anyscope = simd_or(simd_or(simd_or(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
1569            u8error1 = simd_and(u8.xE0_scope, u8.x80_x9F);
1570            u8error2 = simd_and(u8.xED_scope, u8.xA0_xBF);
1571            u8error3 = simd_and(u8.xF0_scope, u8.x80_x8F);
1572            u8error4 = simd_and(u8.xF4_scope, u8.x90_xBF);
1573            u8_error = simd_or(u8_error, simd_or(simd_or(simd_or(u8error1, u8error2), u8error3), u8error4));
1574            carryQ.cq[11] = bitblock::srli<127>(pablo_blk_Advance(simd_and(u8.xEF_scope, u8.xBF), carryQ.get_carry_in(11), EF_BF_pending));
1575            u8_FFFE_FFFF = simd_and(EF_BF_pending, simd_or(u8.xBE, u8.xBF));
1576          }
1577          else {
1578            carryQ.CarryDequeueEnqueue(1, 11);
1579          }
1580          u8mismatch = simd_xor(u8anyscope, u8.suffix);
1581          u8_error = simd_or(u8_error, simd_or(u8mismatch, u8_FFFE_FFFF));
1582          if (bitblock::any(u8_error)) {
1583            error_tracker.NoteError("UTF-8 error found", u8_error);
1584          }
1585        }
1586        else {
1587          carryQ.CarryDequeueEnqueue(0, 12);
1588        }
1589  }
1590  CarryArray<12, 0> carryQ;
1591  };
1592
1593  struct Parse_CtCDPI {
1594  Parse_CtCDPI() { 
1595carryQ.cq[4] = carryQ.carry_flip(carryQ.cq[4]);
1596 }
1597  IDISA_INLINE void do_block(Lex & lex, Marker & marker, CtCDPI_Callouts & ctCDPI_Callouts, Check_streams & check_streams) {
1598                BitBlock CtCDPI_starts, CtCDPI_ends, ctCDPI_mask, v, w, v1, w1, LAngle_scope;
1599                BitBlock PI_opener, CtCD_opener, CtCDPI_opener, CD_closer, DoubleHyphen;
1600                BitBlock DoubleRBracket, PI_closer, CtCDPI_Cursor, PI_Cursor, CD_Ct_Cursor;
1601                BitBlock CD_Cursor, Ct_Cursor, PI_name_end, PI_error, PI_noWS, Ct_error;
1602
1603                BitBlock tempvar0, tempvar1, tempvar2, tempvar3, tempvar4, tempvar5;
1604
1605
1606        ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
1607        ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
1608        ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
1609        ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
1610        ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
1611        ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
1612        ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
1613        ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
1614        CtCDPI_starts = simd<1>::constant<0>();
1615        CtCDPI_ends = simd<1>::constant<0>();
1616        ctCDPI_mask = simd<1>::constant<0>();
1617        v = simd_or(lex.LAngle, lex.Hyphen);
1618        w = simd_or(lex.Hyphen, lex.QMark);
1619        carryQ.cq[0] = bitblock::srli<127>(pablo_blk_Advance(v, carryQ.get_carry_in(0), v1));
1620        carryQ.cq[1] = bitblock::srli<127>(pablo_blk_Advance(w, carryQ.get_carry_in(1), w1));
1621        LAngle_scope = simd_andc(v1, w1);
1622        PI_opener = simd_and(LAngle_scope, lex.QMark);
1623        CtCD_opener = simd_and(LAngle_scope, lex.Exclam);
1624        CtCDPI_opener = simd_or(PI_opener, CtCD_opener);
1625        CD_closer = simd<1>::constant<0>();
1626        DoubleHyphen = simd_and(simd_and(v1, w1), lex.Hyphen);
1627        if ((bitblock::any(lex.RBracket) || carryQ.CarryTest(2, 2))) {
1628          carryQ.cq[2] = bitblock::srli<127>(pablo_blk_Advance(lex.RBracket, carryQ.get_carry_in(2), tempvar0));
1629          DoubleRBracket = simd_and(tempvar0, lex.RBracket);
1630          carryQ.cq[3] = bitblock::srli<127>(pablo_blk_Advance(DoubleRBracket, carryQ.get_carry_in(3), tempvar1));
1631          CD_closer = simd_and(tempvar1, lex.RAngle);
1632        }
1633        else {
1634          carryQ.CarryDequeueEnqueue(2, 2);
1635        }
1636        PI_closer = simd_and(simd_andc(w1, v1), lex.RAngle);
1637        carryQ.cq[4] = bitblock::srli<127>(pablo_blk_ScanToFirst(CtCDPI_opener, carryQ.get_carry_in(4), CtCDPI_Cursor));
1638        if ((bitblock::any(CtCDPI_Cursor) || carryQ.CarryTest(5, 13))) {
1639          CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
1640          PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
1641          carryQ.cq[5] = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor, PI_Cursor), carryQ.get_carry_in(5), CD_Ct_Cursor));
1642          CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
1643          Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
1644          if ((bitblock::any(PI_Cursor) || carryQ.CarryTest(6, 4))) {
1645            ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
1646            carryQ.cq[6] = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor, carryQ.get_carry_in(6), PI_Cursor));
1647            ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
1648            carryQ.cq[7] = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor, lex.NameScan, carryQ.get_carry_in(7), PI_name_end));
1649            PI_error = simd_and(PI_Cursor, PI_name_end);
1650            PI_noWS = simd_andc(PI_name_end, lex.WS);
1651            carryQ.cq[8] = bitblock::srli<127>(pablo_blk_Advance(PI_noWS, carryQ.get_carry_in(8), tempvar2));
1652            PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(tempvar2, PI_closer)));
1653            if (bitblock::any(PI_error)) {
1654              assert_0_error("Error in PI syntax", PI_error);
1655            }
1656            ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
1657            carryQ.cq[9] = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end, simd_not(PI_closer), carryQ.get_carry_in(9), PI_Cursor));
1658            ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
1659            CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
1660          }
1661          else {
1662            carryQ.CarryDequeueEnqueue(6, 4);
1663          }
1664          if ((bitblock::any(CD_Cursor) || carryQ.CarryTest(10, 1))) {
1665            ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
1666            carryQ.cq[10] = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor, simd_not(CD_closer), carryQ.get_carry_in(10), CD_Cursor));
1667            ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
1668            CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
1669          }
1670          else {
1671            carryQ.CarryDequeueEnqueue(10, 1);
1672          }
1673          if ((bitblock::any(Ct_Cursor) || carryQ.CarryTest(11, 5))) {
1674            ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
1675            carryQ.cq[11] = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor, carryQ.get_carry_in(11), Ct_Cursor));
1676            Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
1677            carryQ.cq[12] = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor, carryQ.get_carry_in(12), tempvar3));
1678            carryQ.cq[13] = bitblock::srli<127>(pablo_blk_Advance(tempvar3, carryQ.get_carry_in(13), Ct_Cursor));
1679            carryQ.cq[14] = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor, simd_not(DoubleHyphen), carryQ.get_carry_in(14), tempvar4));
1680            carryQ.cq[15] = bitblock::srli<127>(pablo_blk_Advance(tempvar4, carryQ.get_carry_in(15), Ct_Cursor));
1681            if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)))) {
1682              assert_0_error("Error in comment syntax", simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)));
1683            }
1684            ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
1685            CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
1686          }
1687          else {
1688            carryQ.CarryDequeueEnqueue(11, 5);
1689          }
1690          CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
1691          carryQ.cq[16] = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts, CtCDPI_ends, carryQ.get_carry_in(16), ctCDPI_mask));
1692          if (bitblock::any(simd<1>::constant<0>())) {
1693            assert_0_error("Error in comment, CDATA or processing instruction syntax", simd<1>::constant<0>());
1694          }
1695          carryQ.cq[17] = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor, simd_not(CtCDPI_opener), carryQ.get_carry_in(17), CtCDPI_Cursor));
1696          while (bitblock::any(CtCDPI_Cursor)) {
1697            LocalCarryDeclare(subcarryQ, 13);
1698            CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
1699            PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
1700            subcarryQ.cq[0] = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor, PI_Cursor), simd<1>::constant<0>(), CD_Ct_Cursor));
1701            CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
1702            Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
1703            if (bitblock::any(PI_Cursor)) {
1704              ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
1705              subcarryQ.cq[1] = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor, simd<1>::constant<0>(), PI_Cursor));
1706              ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
1707              subcarryQ.cq[2] = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor, lex.NameScan, simd<1>::constant<0>(), PI_name_end));
1708              PI_error = simd_and(PI_Cursor, PI_name_end);
1709              PI_noWS = simd_andc(PI_name_end, lex.WS);
1710              subcarryQ.cq[3] = bitblock::srli<127>(pablo_blk_Advance(PI_noWS, simd<1>::constant<0>(), tempvar2));
1711              PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(tempvar2, PI_closer)));
1712              if (bitblock::any(PI_error)) {
1713                assert_0_error("Error in PI syntax", PI_error);
1714              }
1715              ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
1716              subcarryQ.cq[4] = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end, simd_not(PI_closer), simd<1>::constant<0>(), PI_Cursor));
1717              ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
1718              CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
1719            }
1720            else {
1721              subcarryQ.CarryDequeueEnqueue(6, 4);
1722            }
1723            if (bitblock::any(CD_Cursor)) {
1724              ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
1725              subcarryQ.cq[5] = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor, simd_not(CD_closer), simd<1>::constant<0>(), CD_Cursor));
1726              ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
1727              CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
1728            }
1729            else {
1730              subcarryQ.CarryDequeueEnqueue(10, 1);
1731            }
1732            if (bitblock::any(Ct_Cursor)) {
1733              ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
1734              subcarryQ.cq[6] = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor, simd<1>::constant<0>(), Ct_Cursor));
1735              Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
1736              subcarryQ.cq[7] = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor, simd<1>::constant<0>(), tempvar3));
1737              subcarryQ.cq[8] = bitblock::srli<127>(pablo_blk_Advance(tempvar3, simd<1>::constant<0>(), Ct_Cursor));
1738              subcarryQ.cq[9] = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor, simd_not(DoubleHyphen), simd<1>::constant<0>(), tempvar4));
1739              subcarryQ.cq[10] = bitblock::srli<127>(pablo_blk_Advance(tempvar4, simd<1>::constant<0>(), Ct_Cursor));
1740              if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)))) {
1741                assert_0_error("Error in comment syntax", simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)));
1742              }
1743              ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
1744              CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
1745            }
1746            else {
1747              subcarryQ.CarryDequeueEnqueue(11, 5);
1748            }
1749            CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
1750            subcarryQ.cq[11] = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts, CtCDPI_ends, simd<1>::constant<0>(), ctCDPI_mask));
1751            if (bitblock::any(simd<1>::constant<0>())) {
1752              assert_0_error("Error in comment, CDATA or processing instruction syntax", simd<1>::constant<0>());
1753            }
1754            subcarryQ.cq[12] = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor, simd_not(CtCDPI_opener), simd<1>::constant<0>(), CtCDPI_Cursor));
1755            carryQ.CarryCombine(subcarryQ.cq, 5, 13);
1756          }
1757        }
1758        else {
1759          carryQ.CarryDequeueEnqueue(5, 13);
1760        }
1761        carryQ.cq[18] = bitblock::srli<127>(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));
1762        check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS, lex.LAngle), tempvar5), CtCDPI_starts), EOF_mask);
1763        marker.LAngle_scope = simd_andc(LAngle_scope, ctCDPI_mask);
1764        marker.Ref_opener = simd_andc(lex.RefStart, ctCDPI_mask);
1765        marker.CD_closer = simd_andc(CD_closer, ctCDPI_mask);
1766        carryQ.CarryQ_Adjust(17);
1767  }
1768  void do_final_block(Lex & lex, Marker & marker, CtCDPI_Callouts & ctCDPI_Callouts, Check_streams & check_streams, BitBlock EOF_mask) {
1769                BitBlock CtCDPI_starts, CtCDPI_ends, ctCDPI_mask, v, w, v1, w1, LAngle_scope;
1770                BitBlock PI_opener, CtCD_opener, CtCDPI_opener, CD_closer, DoubleHyphen;
1771                BitBlock DoubleRBracket, PI_closer, CtCDPI_Cursor, PI_Cursor, CD_Ct_Cursor;
1772                BitBlock CD_Cursor, Ct_Cursor, PI_name_end, PI_error, PI_noWS, Ct_error;
1773
1774                BitBlock tempvar0, tempvar1, tempvar2, tempvar3, tempvar4, tempvar5;
1775
1776
1777        ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
1778        ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
1779        ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
1780        ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
1781        ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
1782        ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
1783        ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
1784        ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
1785        CtCDPI_starts = simd<1>::constant<0>();
1786        CtCDPI_ends = simd<1>::constant<0>();
1787        ctCDPI_mask = simd<1>::constant<0>();
1788        v = simd_or(lex.LAngle, lex.Hyphen);
1789        w = simd_or(lex.Hyphen, lex.QMark);
1790        carryQ.cq[0] = bitblock::srli<127>(pablo_blk_Advance(v, carryQ.get_carry_in(0), v1));
1791        carryQ.cq[1] = bitblock::srli<127>(pablo_blk_Advance(w, carryQ.get_carry_in(1), w1));
1792        LAngle_scope = simd_andc(v1, w1);
1793        PI_opener = simd_and(LAngle_scope, lex.QMark);
1794        CtCD_opener = simd_and(LAngle_scope, lex.Exclam);
1795        CtCDPI_opener = simd_or(PI_opener, CtCD_opener);
1796        CD_closer = simd<1>::constant<0>();
1797        DoubleHyphen = simd_and(simd_and(v1, w1), lex.Hyphen);
1798        if ((bitblock::any(lex.RBracket) || carryQ.CarryTest(2, 2))) {
1799          carryQ.cq[2] = bitblock::srli<127>(pablo_blk_Advance(lex.RBracket, carryQ.get_carry_in(2), tempvar0));
1800          DoubleRBracket = simd_and(tempvar0, lex.RBracket);
1801          carryQ.cq[3] = bitblock::srli<127>(pablo_blk_Advance(DoubleRBracket, carryQ.get_carry_in(3), tempvar1));
1802          CD_closer = simd_and(tempvar1, lex.RAngle);
1803        }
1804        else {
1805          carryQ.CarryDequeueEnqueue(2, 2);
1806        }
1807        PI_closer = simd_and(simd_andc(w1, v1), lex.RAngle);
1808        carryQ.cq[4] = bitblock::srli<127>(pablo_blk_ScanToFirst(CtCDPI_opener, carryQ.get_carry_in(4), CtCDPI_Cursor));
1809        if ((bitblock::any(simd_and(CtCDPI_Cursor, EOF_mask)) || carryQ.CarryTest(5, 13))) {
1810          CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
1811          PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
1812          carryQ.cq[5] = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor, PI_Cursor), carryQ.get_carry_in(5), CD_Ct_Cursor));
1813          CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
1814          Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
1815          if ((bitblock::any(PI_Cursor) || carryQ.CarryTest(6, 4))) {
1816            ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
1817            carryQ.cq[6] = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor, carryQ.get_carry_in(6), PI_Cursor));
1818            ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
1819            carryQ.cq[7] = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor, lex.NameScan, carryQ.get_carry_in(7), PI_name_end));
1820            PI_error = simd_and(PI_Cursor, PI_name_end);
1821            PI_noWS = simd_andc(PI_name_end, lex.WS);
1822            carryQ.cq[8] = bitblock::srli<127>(pablo_blk_Advance(PI_noWS, carryQ.get_carry_in(8), tempvar2));
1823            PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(tempvar2, PI_closer)));
1824            if (bitblock::any(PI_error)) {
1825              assert_0_error("Error in PI syntax", PI_error);
1826            }
1827            ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
1828            carryQ.cq[9] = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end, simd_andc(EOF_mask, PI_closer), carryQ.get_carry_in(9), PI_Cursor));
1829            ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
1830            CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
1831          }
1832          else {
1833            carryQ.CarryDequeueEnqueue(6, 4);
1834          }
1835          if ((bitblock::any(CD_Cursor) || carryQ.CarryTest(10, 1))) {
1836            ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
1837            carryQ.cq[10] = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor, simd_andc(EOF_mask, CD_closer), carryQ.get_carry_in(10), CD_Cursor));
1838            ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
1839            CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
1840          }
1841          else {
1842            carryQ.CarryDequeueEnqueue(10, 1);
1843          }
1844          if ((bitblock::any(Ct_Cursor) || carryQ.CarryTest(11, 5))) {
1845            ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
1846            carryQ.cq[11] = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor, carryQ.get_carry_in(11), Ct_Cursor));
1847            Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
1848            carryQ.cq[12] = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor, carryQ.get_carry_in(12), tempvar3));
1849            carryQ.cq[13] = bitblock::srli<127>(pablo_blk_Advance(tempvar3, carryQ.get_carry_in(13), Ct_Cursor));
1850            carryQ.cq[14] = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor, simd_andc(EOF_mask, DoubleHyphen), carryQ.get_carry_in(14), tempvar4));
1851            carryQ.cq[15] = bitblock::srli<127>(pablo_blk_Advance(tempvar4, carryQ.get_carry_in(15), Ct_Cursor));
1852            if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)))) {
1853              assert_0_error("Error in comment syntax", simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)));
1854            }
1855            ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
1856            CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
1857          }
1858          else {
1859            carryQ.CarryDequeueEnqueue(11, 5);
1860          }
1861          CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
1862          carryQ.cq[16] = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts, CtCDPI_ends, carryQ.get_carry_in(16), ctCDPI_mask));
1863          if (bitblock::any(simd_andc(ctCDPI_mask, EOF_mask))) {
1864            assert_0_error("Error in comment, CDATA or processing instruction syntax", simd_andc(ctCDPI_mask, EOF_mask));
1865          }
1866          carryQ.cq[17] = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), carryQ.get_carry_in(17), CtCDPI_Cursor));
1867          while (bitblock::any(simd_and(CtCDPI_Cursor, EOF_mask))) {
1868            LocalCarryDeclare(subcarryQ, 13);
1869            CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
1870            PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
1871            subcarryQ.cq[0] = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor, PI_Cursor), simd<1>::constant<0>(), CD_Ct_Cursor));
1872            CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
1873            Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
1874            if (bitblock::any(PI_Cursor)) {
1875              ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
1876              subcarryQ.cq[1] = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor, simd<1>::constant<0>(), PI_Cursor));
1877              ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
1878              subcarryQ.cq[2] = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor, lex.NameScan, simd<1>::constant<0>(), PI_name_end));
1879              PI_error = simd_and(PI_Cursor, PI_name_end);
1880              PI_noWS = simd_andc(PI_name_end, lex.WS);
1881              subcarryQ.cq[3] = bitblock::srli<127>(pablo_blk_Advance(PI_noWS, simd<1>::constant<0>(), tempvar2));
1882              PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(tempvar2, PI_closer)));
1883              if (bitblock::any(PI_error)) {
1884                assert_0_error("Error in PI syntax", PI_error);
1885              }
1886              ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
1887              subcarryQ.cq[4] = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end, simd_andc(EOF_mask, PI_closer), simd<1>::constant<0>(), PI_Cursor));
1888              ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
1889              CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
1890            }
1891            else {
1892              subcarryQ.CarryDequeueEnqueue(6, 4);
1893            }
1894            if (bitblock::any(CD_Cursor)) {
1895              ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
1896              subcarryQ.cq[5] = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor, simd_andc(EOF_mask, CD_closer), simd<1>::constant<0>(), CD_Cursor));
1897              ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
1898              CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
1899            }
1900            else {
1901              subcarryQ.CarryDequeueEnqueue(10, 1);
1902            }
1903            if (bitblock::any(Ct_Cursor)) {
1904              ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
1905              subcarryQ.cq[6] = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor, simd<1>::constant<0>(), Ct_Cursor));
1906              Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
1907              subcarryQ.cq[7] = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor, simd<1>::constant<0>(), tempvar3));
1908              subcarryQ.cq[8] = bitblock::srli<127>(pablo_blk_Advance(tempvar3, simd<1>::constant<0>(), Ct_Cursor));
1909              subcarryQ.cq[9] = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor, simd_andc(EOF_mask, DoubleHyphen), simd<1>::constant<0>(), tempvar4));
1910              subcarryQ.cq[10] = bitblock::srli<127>(pablo_blk_Advance(tempvar4, simd<1>::constant<0>(), Ct_Cursor));
1911              if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)))) {
1912                assert_0_error("Error in comment syntax", simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)));
1913              }
1914              ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
1915              CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
1916            }
1917            else {
1918              subcarryQ.CarryDequeueEnqueue(11, 5);
1919            }
1920            CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
1921            subcarryQ.cq[11] = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts, CtCDPI_ends, simd<1>::constant<0>(), ctCDPI_mask));
1922            if (bitblock::any(simd_andc(ctCDPI_mask, EOF_mask))) {
1923              assert_0_error("Error in comment, CDATA or processing instruction syntax", simd_andc(ctCDPI_mask, EOF_mask));
1924            }
1925            subcarryQ.cq[12] = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), simd<1>::constant<0>(), CtCDPI_Cursor));
1926            carryQ.CarryCombine(subcarryQ.cq, 5, 13);
1927          }
1928        }
1929        else {
1930          carryQ.CarryDequeueEnqueue(5, 13);
1931        }
1932        carryQ.cq[18] = bitblock::srli<127>(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));
1933        check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS, lex.LAngle), tempvar5), CtCDPI_starts), EOF_mask);
1934        marker.LAngle_scope = simd_andc(LAngle_scope, ctCDPI_mask);
1935        marker.Ref_opener = simd_andc(lex.RefStart, ctCDPI_mask);
1936        marker.CD_closer = simd_andc(CD_closer, ctCDPI_mask);
1937  }
1938  CarryArray<19, 0> carryQ;
1939  };
1940
1941  struct Do_check_streams {
1942 
1943  IDISA_INLINE void do_block(Marker & marker, Tag_Callouts & tag_Callouts, Check_streams & check_streams) {
1944
1945
1946
1947
1948
1949        if (bitblock::any(simd_andc(marker.CD_closer, tag_Callouts.AttVal_spans))) {
1950          assert_0_error("Error: ]]> in text", simd_andc(marker.CD_closer, tag_Callouts.AttVal_spans));
1951        }
1952        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);
1953        check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends, tag_Callouts.AttName_ends);
1954        check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans, marker.Ref_opener);
1955  }
1956  void do_final_block(Marker & marker, Tag_Callouts & tag_Callouts, Check_streams & check_streams, BitBlock EOF_mask) {
1957
1958
1959
1960
1961
1962        if (bitblock::any(simd_andc(marker.CD_closer, tag_Callouts.AttVal_spans))) {
1963          assert_0_error("Error: ]]> in text", simd_andc(marker.CD_closer, tag_Callouts.AttVal_spans));
1964        }
1965        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);
1966        check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends, tag_Callouts.AttName_ends);
1967        check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans, marker.Ref_opener);
1968  }
1969 
1970  };
1971
1972  struct Form_Length_Group_Bitstreams {
1973  Form_Length_Group_Bitstreams() { 
1974 }
1975  IDISA_INLINE void do_block(Tag_Callouts & tag_Callouts) {
1976                BitBlock remaining_starts, remaining_ends, temp;
1977
1978
1979
1980
1981        remaining_starts = tag_Callouts.ElemName_starts;
1982        remaining_ends = tag_Callouts.ElemName_ends;
1983        temp = tag_Callouts.ElemName_starts;
1984        carryQ.cq[0] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(0), temp));
1985        tag_Callouts.ElemName_ends_1 = simd_and(temp, remaining_ends);
1986        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_1);
1987        carryQ.cq[1] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(1), temp));
1988        tag_Callouts.ElemName_ends_2 = simd_and(temp, remaining_ends);
1989        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_2);
1990        carryQ.cq[2] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(2), temp));
1991        tag_Callouts.ElemName_ends_3 = simd_and(temp, remaining_ends);
1992        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_3);
1993        carryQ.cq[3] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(3), temp));
1994        tag_Callouts.ElemName_ends_4 = simd_and(temp, remaining_ends);
1995        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_4);
1996        carryQ.cq[4] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(4), temp));
1997        tag_Callouts.ElemName_ends_5 = simd_and(temp, remaining_ends);
1998        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_5);
1999        carryQ.cq[5] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(5), temp));
2000        tag_Callouts.ElemName_ends_6 = simd_and(temp, remaining_ends);
2001        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_6);
2002        carryQ.cq[6] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(6), temp));
2003        tag_Callouts.ElemName_ends_7 = simd_and(temp, remaining_ends);
2004        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_7);
2005        carryQ.cq[7] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(7), temp));
2006        tag_Callouts.ElemName_ends_8 = simd_and(temp, remaining_ends);
2007        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_8);
2008        carryQ.cq[8] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(8), temp));
2009        tag_Callouts.ElemName_ends_9 = simd_and(temp, remaining_ends);
2010        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_9);
2011        carryQ.cq[9] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(9), temp));
2012        tag_Callouts.ElemName_ends_10 = simd_and(temp, remaining_ends);
2013        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_10);
2014        carryQ.cq[10] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(10), temp));
2015        tag_Callouts.ElemName_ends_11 = simd_and(temp, remaining_ends);
2016        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_11);
2017        carryQ.cq[11] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(11), temp));
2018        tag_Callouts.ElemName_ends_12 = simd_and(temp, remaining_ends);
2019        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_12);
2020        carryQ.cq[12] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(12), temp));
2021        tag_Callouts.ElemName_ends_13 = simd_and(temp, remaining_ends);
2022        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_13);
2023        carryQ.cq[13] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(13), temp));
2024        tag_Callouts.ElemName_ends_14 = simd_and(temp, remaining_ends);
2025        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_14);
2026        carryQ.cq[14] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(14), temp));
2027        tag_Callouts.ElemName_ends_15 = simd_and(temp, remaining_ends);
2028        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_15);
2029        carryQ.cq[15] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(15), temp));
2030        tag_Callouts.ElemName_ends_16 = simd_and(temp, remaining_ends);
2031        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_16);
2032        tag_Callouts.ElemName_ends_17_and_longer = remaining_ends;
2033        carryQ.CarryQ_Adjust(16);
2034  }
2035  void do_final_block(Tag_Callouts & tag_Callouts, BitBlock EOF_mask) {
2036                BitBlock remaining_starts, remaining_ends, temp;
2037
2038
2039
2040
2041        remaining_starts = tag_Callouts.ElemName_starts;
2042        remaining_ends = tag_Callouts.ElemName_ends;
2043        temp = tag_Callouts.ElemName_starts;
2044        carryQ.cq[0] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(0), temp));
2045        tag_Callouts.ElemName_ends_1 = simd_and(temp, remaining_ends);
2046        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_1);
2047        carryQ.cq[1] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(1), temp));
2048        tag_Callouts.ElemName_ends_2 = simd_and(temp, remaining_ends);
2049        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_2);
2050        carryQ.cq[2] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(2), temp));
2051        tag_Callouts.ElemName_ends_3 = simd_and(temp, remaining_ends);
2052        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_3);
2053        carryQ.cq[3] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(3), temp));
2054        tag_Callouts.ElemName_ends_4 = simd_and(temp, remaining_ends);
2055        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_4);
2056        carryQ.cq[4] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(4), temp));
2057        tag_Callouts.ElemName_ends_5 = simd_and(temp, remaining_ends);
2058        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_5);
2059        carryQ.cq[5] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(5), temp));
2060        tag_Callouts.ElemName_ends_6 = simd_and(temp, remaining_ends);
2061        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_6);
2062        carryQ.cq[6] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(6), temp));
2063        tag_Callouts.ElemName_ends_7 = simd_and(temp, remaining_ends);
2064        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_7);
2065        carryQ.cq[7] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(7), temp));
2066        tag_Callouts.ElemName_ends_8 = simd_and(temp, remaining_ends);
2067        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_8);
2068        carryQ.cq[8] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(8), temp));
2069        tag_Callouts.ElemName_ends_9 = simd_and(temp, remaining_ends);
2070        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_9);
2071        carryQ.cq[9] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(9), temp));
2072        tag_Callouts.ElemName_ends_10 = simd_and(temp, remaining_ends);
2073        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_10);
2074        carryQ.cq[10] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(10), temp));
2075        tag_Callouts.ElemName_ends_11 = simd_and(temp, remaining_ends);
2076        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_11);
2077        carryQ.cq[11] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(11), temp));
2078        tag_Callouts.ElemName_ends_12 = simd_and(temp, remaining_ends);
2079        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_12);
2080        carryQ.cq[12] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(12), temp));
2081        tag_Callouts.ElemName_ends_13 = simd_and(temp, remaining_ends);
2082        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_13);
2083        carryQ.cq[13] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(13), temp));
2084        tag_Callouts.ElemName_ends_14 = simd_and(temp, remaining_ends);
2085        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_14);
2086        carryQ.cq[14] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(14), temp));
2087        tag_Callouts.ElemName_ends_15 = simd_and(temp, remaining_ends);
2088        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_15);
2089        carryQ.cq[15] = bitblock::srli<127>(pablo_blk_Advance(temp, carryQ.get_carry_in(15), temp));
2090        tag_Callouts.ElemName_ends_16 = simd_and(temp, remaining_ends);
2091        remaining_ends = simd_andc(remaining_ends, tag_Callouts.ElemName_ends_16);
2092        tag_Callouts.ElemName_ends_17_and_longer = remaining_ends;
2093  }
2094  CarryArray<16, 0> carryQ;
2095  };
2096
2097  struct Validate_xml_names {
2098  Validate_xml_names() { 
2099 }
2100  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) {
2101                BitBlock PI_names, GenRefs, ElemNames, AttNames, qname_stream, ncname_stream;
2102                BitBlock name_stream, name_start, name_cursor, void_prefix_err, namespace_sep;
2103                BitBlock local_part_start, local_part_err, colon2_err, ncname_err;
2104                BitBlock namespace_error;
2105
2106                BitBlock tempvar0, tempvar1, tempvar2, tempvar3;
2107
2108
2109        carryQ.cq[0] = bitblock::srli<127>(pablo_blk_SpanUpTo(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carryQ.get_carry_in(0), PI_names));
2110        carryQ.cq[1] = bitblock::srli<127>(pablo_blk_SpanUpTo(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carryQ.get_carry_in(1), GenRefs));
2111        carryQ.cq[2] = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carryQ.get_carry_in(2), ElemNames));
2112        carryQ.cq[3] = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carryQ.get_carry_in(3), AttNames));
2113        qname_stream = simd_or(ElemNames, AttNames);
2114        ncname_stream = simd_or(PI_names, GenRefs);
2115        name_stream = simd_or(qname_stream, ncname_stream);
2116        carryQ.cq[4] = bitblock::srli<127>(pablo_blk_Advance(name_stream, carryQ.get_carry_in(4), tempvar0));
2117        name_start = simd_andc(name_stream, tempvar0);
2118        carryQ.cq[5] = bitblock::srli<127>(pablo_blk_Advance(name_stream, carryQ.get_carry_in(5), tempvar1));
2119        name_cursor = simd_andc(name_stream, tempvar1);
2120        void_prefix_err = simd_and(name_cursor, lex.Colon);
2121        carryQ.cq[6] = bitblock::srli<127>(pablo_blk_ScanThru(name_cursor, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(6), tempvar2));
2122        namespace_sep = simd_and(tempvar2, lex.Colon);
2123        carryQ.cq[7] = bitblock::srli<127>(pablo_blk_Advance(namespace_sep, carryQ.get_carry_in(7), local_part_start));
2124        local_part_err = simd_andc(local_part_start, lex.NameScan);
2125        carryQ.cq[8] = bitblock::srli<127>(pablo_blk_ScanThru(local_part_start, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(8), tempvar3));
2126        colon2_err = simd_and(tempvar3, lex.Colon);
2127        ncname_err = simd_and(ncname_stream, lex.Colon);
2128        namespace_error = simd_or(simd_or(simd_or(void_prefix_err, local_part_err), colon2_err), ncname_err);
2129        if (bitblock::any(namespace_error)) {
2130          error_tracker.NoteError("error found", namespace_error);
2131        }
2132        check_streams.non_ascii_name_starts = simd_andc(name_start, lex.ASCII_name_start);
2133        check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream, name_start), lex.ASCII_name_char), u8.suffix);
2134        carryQ.CarryQ_Adjust(9);
2135  }
2136  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) {
2137                BitBlock PI_names, GenRefs, ElemNames, AttNames, qname_stream, ncname_stream;
2138                BitBlock name_stream, name_start, name_cursor, void_prefix_err, namespace_sep;
2139                BitBlock local_part_start, local_part_err, colon2_err, ncname_err;
2140                BitBlock namespace_error;
2141
2142                BitBlock tempvar0, tempvar1, tempvar2, tempvar3;
2143
2144
2145        carryQ.cq[0] = bitblock::srli<127>(pablo_blk_SpanUpTo(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carryQ.get_carry_in(0), PI_names));
2146        carryQ.cq[1] = bitblock::srli<127>(pablo_blk_SpanUpTo(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carryQ.get_carry_in(1), GenRefs));
2147        carryQ.cq[2] = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carryQ.get_carry_in(2), ElemNames));
2148        carryQ.cq[3] = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carryQ.get_carry_in(3), AttNames));
2149        qname_stream = simd_or(ElemNames, AttNames);
2150        ncname_stream = simd_or(PI_names, GenRefs);
2151        name_stream = simd_or(qname_stream, ncname_stream);
2152        carryQ.cq[4] = bitblock::srli<127>(pablo_blk_Advance(name_stream, carryQ.get_carry_in(4), tempvar0));
2153        name_start = simd_andc(name_stream, tempvar0);
2154        carryQ.cq[5] = bitblock::srli<127>(pablo_blk_Advance(name_stream, carryQ.get_carry_in(5), tempvar1));
2155        name_cursor = simd_andc(name_stream, tempvar1);
2156        void_prefix_err = simd_and(name_cursor, lex.Colon);
2157        carryQ.cq[6] = bitblock::srli<127>(pablo_blk_ScanThru(name_cursor, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(6), tempvar2));
2158        namespace_sep = simd_and(tempvar2, lex.Colon);
2159        carryQ.cq[7] = bitblock::srli<127>(pablo_blk_Advance(namespace_sep, carryQ.get_carry_in(7), local_part_start));
2160        local_part_err = simd_andc(local_part_start, lex.NameScan);
2161        carryQ.cq[8] = bitblock::srli<127>(pablo_blk_ScanThru(local_part_start, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(8), tempvar3));
2162        colon2_err = simd_and(tempvar3, lex.Colon);
2163        ncname_err = simd_and(ncname_stream, lex.Colon);
2164        namespace_error = simd_or(simd_or(simd_or(void_prefix_err, local_part_err), colon2_err), ncname_err);
2165        if (bitblock::any(namespace_error)) {
2166          error_tracker.NoteError("error found", namespace_error);
2167        }
2168        check_streams.non_ascii_name_starts = simd_andc(name_start, lex.ASCII_name_start);
2169        check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream, name_start), lex.ASCII_name_char), u8.suffix);
2170  }
2171  CarryArray<9, 0> carryQ;
2172  };
2173
2174  struct Compute_Hash_Value_Bitstream {
2175 
2176  IDISA_INLINE void do_block(Hash_data & hash_data, Basis_bits & basis_bits) {
2177
2178
2179
2180
2181
2182        hash_data.Hash_value = simd_xor(simd_xor(basis_bits.bit_2, basis_bits.bit_4), basis_bits.bit_6);
2183  }
2184  void do_final_block(Hash_data & hash_data, Basis_bits & basis_bits, BitBlock EOF_mask) {
2185
2186
2187
2188
2189
2190        hash_data.Hash_value = simd_xor(simd_xor(basis_bits.bit_2, basis_bits.bit_4), basis_bits.bit_6);
2191  }
2192 
2193  };
2194
2195  struct Add_scope_streams {
2196  Add_scope_streams() { 
2197 }
2198  IDISA_INLINE void do_block(Lex & lex, Scope1 & scope1) {
2199                BitBlock v, w, v1, w1;
2200
2201
2202
2203
2204        v = simd_or(lex.LAngle, lex.Hyphen);
2205        w = simd_or(lex.Hyphen, lex.QMark);
2206        carryQ.cq[0] = bitblock::srli<127>(pablo_blk_Advance(v, carryQ.get_carry_in(0), v1));
2207        carryQ.cq[1] = bitblock::srli<127>(pablo_blk_Advance(w, carryQ.get_carry_in(1), w1));
2208        scope1.LAngle = simd_andc(v1, w1);
2209        scope1.Hyphen = simd_and(v1, w1);
2210        scope1.QMark = simd_andc(w1, v1);
2211        scope1.RefStart = simd<1>::constant<0>();
2212        carryQ.CarryQ_Adjust(2);
2213  }
2214  void do_final_block(Lex & lex, Scope1 & scope1, BitBlock EOF_mask) {
2215                BitBlock v, w, v1, w1;
2216
2217
2218
2219
2220        v = simd_or(lex.LAngle, lex.Hyphen);
2221        w = simd_or(lex.Hyphen, lex.QMark);
2222        carryQ.cq[0] = bitblock::srli<127>(pablo_blk_Advance(v, carryQ.get_carry_in(0), v1));
2223        carryQ.cq[1] = bitblock::srli<127>(pablo_blk_Advance(w, carryQ.get_carry_in(1), w1));
2224        scope1.LAngle = simd_andc(v1, w1);
2225        scope1.Hyphen = simd_and(v1, w1);
2226        scope1.QMark = simd_andc(w1, v1);
2227        scope1.RefStart = simd<1>::constant<0>();
2228  }
2229  CarryArray<2, 0> carryQ;
2230  };
2231
2232
2233
2234#include <simd-lib/transpose.hpp>
2235#include <post_process.hpp>
2236/*
2237static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
2238  s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
2239        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);
2240}
2241
2242static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask) {
2243  s2p_do_block(U8, basis_bits);
2244  basis_bits.bit_0 = simd_and(basis_bits.bit_0, EOF_mask);
2245  basis_bits.bit_1 = simd_and(basis_bits.bit_1, EOF_mask);
2246  basis_bits.bit_2 = simd_and(basis_bits.bit_2, EOF_mask);
2247  basis_bits.bit_3 = simd_and(basis_bits.bit_3, EOF_mask);
2248  basis_bits.bit_4 = simd_and(basis_bits.bit_4, EOF_mask);
2249  basis_bits.bit_5 = simd_and(basis_bits.bit_5, EOF_mask);
2250  basis_bits.bit_6 = simd_and(basis_bits.bit_6, EOF_mask);
2251  basis_bits.bit_7 = simd_and(basis_bits.bit_7, EOF_mask);
2252}
2253*/
2254static inline void print_basis_bits(Basis_bits & basis_bits){
2255        print_register("bit0:",basis_bits.bit_0);
2256        print_register("bit1:",basis_bits.bit_1);
2257        print_register("bit2:",basis_bits.bit_2);
2258        print_register("bit3:",basis_bits.bit_3);
2259        print_register("bit4:",basis_bits.bit_4);
2260        print_register("bit5:",basis_bits.bit_5);
2261        print_register("bit6:",basis_bits.bit_6);
2262        print_register("bit7:",basis_bits.bit_7);                                       
2263}
2264
2265static inline void print_elem_vec(vector<char>* vec, int size){
2266        cout << "vector: ";
2267        for (int i = 0; i<size ; i++){
2268                cout << (int)(*vec)[i] <<" ";
2269        }
2270        cout << endl;
2271}
2272
2273
2274static inline void validate(){
2275        struct Elem elem;
2276        Validate_Elem_Vec validate_Elem_Vec;
2277        cout << "vector size " << gid_vec.size() << endl;
2278        int lgth = gid_vec.size();
2279        int remaining = 0;
2280        Basis_bits temp_basis_bits;
2281        if (lgth != 0){
2282                int i = 0;
2283                int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
2284                remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
2285                for (i = 0;i < num_block; i++){
2286//                      s2p_do_block((BytePack*)(vector_11[i]),temp_basis_bits);
2287                        s2p_do_block((BytePack*)(&(gid_vec[i])), temp_basis_bits);
2288                        print_elem_vec(&(gid_vec),lgth);
2289                        print_basis_bits(temp_basis_bits);
2290//                      (BytePack*)(iter->second)
2291                        validate_Elem_Vec.do_block(elem, temp_basis_bits);
2292                        cout << i ;
2293                }
2294                cout << endl;
2295                if (remaining !=0){
2296                        BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
2297                        s2p_do_final_block((BytePack*)(&(gid_vec[i])), temp_basis_bits,EOF_mask);
2298                        print_elem_vec(&(gid_vec),lgth);
2299                        print_basis_bits(temp_basis_bits);
2300                        validate_Elem_Vec.do_final_block(elem, temp_basis_bits, EOF_mask);
2301                }
2302        }
2303/*
2304        vector<int> test;
2305        for(int i = 1;i <12; i++){
2306                test.push_back(i);
2307        }
2308//      int test[] = {1,2,3,4,5,6,7,8,9,10,11};
2309        Basis_bits temp_basis_bits;
2310        BitBlock EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-44));
2311        s2p_do_final_block((BytePack*)(&(test[0])), temp_basis_bits,EOF_mask);
2312        print_basis_bits(temp_basis_bits);
2313*/
2314/*
2315        for (map<char, vector<char>* > ::const_iterator iter = elem_vec_map.begin(); iter!= elem_vec_map.end(); ++iter){
2316                int i = 0;
2317                int lgth = (*(iter->second)).size();
2318                int remaining;
2319                if (lgth != 0){
2320                        cout <<"vector key "<< (int)iter->first << endl;
2321//                      cout <<"vector ptr" << iter->second<<endl;
2322               
2323                        cout <<"vector size: " << lgth << endl;
2324                        int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
2325                        remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
2326                        for (i = 0;i < num_block; i++){
2327                                Basis_bits temp_basis_bits;
2328                                s2p_do_block(((BytePack*)(&(*(iter->second))[i])), temp_basis_bits);
2329                                print_elem_vec(iter->second,lgth);
2330                                print_basis_bits(temp_basis_bits);
2331//                              (BytePack*)(iter->second)
2332                                cout << i ;
2333                        }
2334                        cout << endl;
2335                        if (remaining !=0){
2336                                BitBlock EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-remaining));
2337                                Basis_bits temp_basis_bits;
2338                                s2p_do_final_block(((BytePack*)(&(*(iter->second))[i])), temp_basis_bits,EOF_mask);
2339                                print_elem_vec((iter->second)+i,lgth);
2340                                print_basis_bits(temp_basis_bits);
2341                        }
2342                }                       
2343        }
2344*/
2345}
2346
2347static inline void vectoring(Tag_Callouts & tag_Callouts, Hash_data & hash_data,char *source,int block_base){
2348
2349        elem_starts = tag_Callouts.ElemName_starts;
2350    hashvalues[1] = hash_data.Hash_value;
2351   
2352        StreamScanLengthGrouping(source,block_base,(ScanBlock *) &tag_Callouts.ElemName_ends,(ScanBlock *) &tag_Callouts.Tag_closing, sizeof(BitBlock)/sizeof(ScanBlock));
2353       
2354        // Store the last starting position in case we hit boundary case
2355    previous_block_last_elem_start = - count_reverse_zeroes(elem_starts);
2356
2357    //copy current hash value data as previous one.
2358    memmove (&hashvalues[0], &hashvalues[1], 16);
2359}
2360/*
2361static 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){
2362
2363
2364    //NOTE: We are NOT handling the case for an extremely long symbol name (length > 1541).
2365    //      TagMatcher will crash if we feed a long symbol name.
2366    //      Sample file: test/long_sym_name.xml
2367
2368    tracker.StoreNewlines(lex.LF);
2369    elem_starts = tag_Callouts.ElemName_starts;
2370    hashvalues[1] = hash_data.Hash_value;
2371
2372        StreamScanLengthGrouping((ScanBlock *) &tag_Callouts.ElemName_ends,(ScanBlock *) &tag_Callouts.Tag_closing, sizeof(BitBlock)/sizeof(ScanBlock));
2373       
2374/*
2375    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_1) )
2376    {
2377        StreamScanLengthGrouping<1>((ScanBlock *) &tag_Callouts.ElemName_ends_1,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
2378    }
2379
2380    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_2) )
2381    {
2382        StreamScanLengthGrouping<2>((ScanBlock *) &tag_Callouts.ElemName_ends_2,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
2383    }
2384
2385    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_3) )
2386    {
2387        StreamScanLengthGrouping<3>((ScanBlock *) &tag_Callouts.ElemName_ends_3,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
2388    }
2389
2390    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_4) )
2391    {
2392        StreamScanLengthGrouping<4>((ScanBlock *) &tag_Callouts.ElemName_ends_4,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
2393    }
2394
2395    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_5) )
2396    {
2397        StreamScanLengthGrouping<5>((ScanBlock *) &tag_Callouts.ElemName_ends_5,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
2398    }
2399
2400    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_6) )
2401    {
2402        StreamScanLengthGrouping<6>((ScanBlock *) &tag_Callouts.ElemName_ends_6,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
2403    }
2404
2405    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_7) )
2406    {
2407        StreamScanLengthGrouping<7>((ScanBlock *) &tag_Callouts.ElemName_ends_7,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
2408    }
2409
2410    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_8) )
2411    {
2412        StreamScanLengthGrouping<8>((ScanBlock *) &tag_Callouts.ElemName_ends_8,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
2413    }
2414
2415    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_9) )
2416    {
2417        StreamScanLengthGrouping<9>((ScanBlock *) &tag_Callouts.ElemName_ends_9,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
2418    }
2419
2420    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_10) )
2421    {
2422        StreamScanLengthGrouping<10>((ScanBlock *) &tag_Callouts.ElemName_ends_10,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
2423    }
2424
2425    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_11) )
2426    {
2427        StreamScanLengthGrouping<11>((ScanBlock *) &tag_Callouts.ElemName_ends_11,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
2428    }
2429
2430    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_12) )
2431    {
2432        StreamScanLengthGrouping<12>((ScanBlock *) &tag_Callouts.ElemName_ends_12,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
2433    }
2434
2435    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_13) )
2436    {
2437        StreamScanLengthGrouping<13>((ScanBlock *) &tag_Callouts.ElemName_ends_13,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
2438    }
2439
2440    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_14) )
2441    {
2442        StreamScanLengthGrouping<14>((ScanBlock *) &tag_Callouts.ElemName_ends_14,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
2443    }
2444
2445    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_15) )
2446    {
2447        StreamScanLengthGrouping<15>((ScanBlock *) &tag_Callouts.ElemName_ends_15,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
2448    }
2449
2450    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_16) )
2451    {
2452        StreamScanLengthGrouping<16>((ScanBlock *) &tag_Callouts.ElemName_ends_16,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
2453    }
2454
2455    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_17_and_longer) )
2456    {
2457        StreamScanLengthGrouping<17>((ScanBlock *) &tag_Callouts.ElemName_ends_17_and_longer,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
2458    }
2459
2460*/
2461
2462
2463/*
2464    // Store the last starting position in case we hit boundary case
2465    previous_block_last_elem_start = - count_reverse_zeroes(elem_starts);
2466
2467    //copy current hash value data as previous one.
2468    memmove (&hashvalues[0], &hashvalues[1], 16);
2469
2470    if (bitblock::any(simd_or(check_streams.non_ascii_name_starts, check_streams.non_ascii_names))) {
2471      StreamScan((ScanBlock *) &check_streams.non_ascii_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), NameStrt_check);
2472      StreamScan((ScanBlock *) &check_streams.non_ascii_names, sizeof(BitBlock)/sizeof(ScanBlock), Name_check);
2473    }
2474
2475    if (bitblock::any(ctCDPI_Callouts.PI_name_starts)){
2476      StreamScan((ScanBlock *) &ctCDPI_Callouts.PI_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), PIName_check);
2477    }
2478
2479    if (bitblock::any(ctCDPI_Callouts.CD_starts)){
2480      StreamScan((ScanBlock *) &ctCDPI_Callouts.CD_starts, sizeof(BitBlock)/sizeof(ScanBlock), CD_check);
2481    }
2482
2483    if (bitblock::any(ref_Callouts.GenRef_starts)){
2484      StreamScan((ScanBlock *) &ref_Callouts.GenRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), GenRef_check);
2485    }
2486
2487    if (bitblock::any(ref_Callouts.DecRef_starts)){
2488      StreamScan((ScanBlock *) &ref_Callouts.DecRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), DecRef_check);
2489    }
2490
2491    if (bitblock::any(ref_Callouts.HexRef_starts)){
2492      StreamScan((ScanBlock *) &ref_Callouts.HexRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), HexRef_check);
2493    }
2494
2495    if (bitblock::any(check_streams.att_refs)){
2496      StreamScan((ScanBlock *) &check_streams.att_refs, sizeof(BitBlock)/sizeof(ScanBlock), AttRef_check);
2497    }
2498
2499//    error_tracker.If_Error_Report_First();
2500/*
2501    matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
2502    tracker.AdvanceBlock();
2503    */
2504    /*
2505}
2506*/
2507
2508static inline void print_GIDS()
2509{
2510    int span_count = gids.size();
2511    for(int i=0;i<span_count;i++) {
2512             cout << gids[i] << " ";
2513    }
2514    cout << endl;
2515}
2516
2517static inline int test(int)
2518{
2519    return 0;
2520}
2521
2522void do_process(FILE *infile, FILE *outfile) {
2523
2524        ///////////////
2525        //gid file
2526        ///////////////
2527        gid_writein = fopen("gid.out","w");
2528  struct U8 u8;
2529
2530  struct Lex lex;
2531
2532  struct Scope1 scope1;
2533
2534  struct Marker marker;
2535
2536  struct CtCDPI_Callouts ctCDPI_Callouts;
2537
2538  struct Ref_Callouts ref_Callouts;
2539
2540  struct Hash_data hash_data;
2541
2542  struct Tag_Callouts tag_Callouts;
2543
2544  struct Basis_bits basis_bits;
2545
2546  struct Check_streams check_streams;
2547
2548  struct Xml_names xml_names;
2549
2550  struct Elem elem;
2551
2552
2553
2554        #ifndef STL_ALIGNED_VECTOR
2555                TagMatcher<SEGMENT_SIZE,LOOKAHEAD_SIZE> matcher;
2556        #endif
2557        ///////////////////////////////////////////////////
2558        //preload element_IDs into symbol table from schema
2559        ///////////////////////////////////////////////////
2560        FILE *element_ID_in = fopen("../test/element_ID","r");
2561        char symble[50];
2562        int index;
2563        if(element_ID_in == NULL){
2564                printf("Error opening element_ID file.\n");
2565                exit(0);
2566        }
2567        hashvalues[1] = hash_data.Hash_value;
2568        while(fscanf(element_ID_in,"%s %d\n",&symble[0],&index)==2){
2569                int lgth = strlen(symble);
2570                int hashvalue = compute_hash_value(lgth,1);
2571                cout << symble <<" "<< lgth<<" "<<hashvalue << endl;
2572                int gid = 0;
2573                switch (lgth)
2574        {
2575                        case 1:
2576                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<1>(symble, hashvalue);
2577                        break;
2578                        case 2:
2579                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<2>(symble, hashvalue);
2580                        break;
2581                        case 3:
2582                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<3>(symble, hashvalue);
2583                        break;
2584                        case 4:
2585                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<4>(symble, hashvalue);
2586                        break;
2587                        case 5:
2588                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<5>(symble, hashvalue);
2589                        break;
2590                        case 6:
2591                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<6>(symble, hashvalue);
2592                        break;
2593                        case 7:
2594                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<7>(symble, hashvalue);
2595                        break;
2596                        case 8:
2597                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<8>(symble, hashvalue);
2598                        break;
2599                        case 9:
2600                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<9>(symble, hashvalue);
2601                        break;
2602                        case 10:
2603                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<10>(symble, hashvalue);
2604                        break;
2605                        case 11:
2606                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<11>(symble, hashvalue);
2607                        break;
2608                        case 12:
2609                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<12>(symble, hashvalue);
2610                        break;
2611                        case 13:
2612                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<13>(symble, hashvalue);
2613                        break;
2614                        case 14:
2615                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<14>(symble, hashvalue);
2616                        break;
2617                        case 15:
2618                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<15>(symble, hashvalue);
2619                        break;
2620                        case 16:
2621                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<16>(symble, hashvalue);
2622                        break;
2623                        default:
2624                        gid = pbgs_symbol_table.Lookup_or_Insert_Name(symble, hashvalue, lgth);
2625                        break;         
2626                }
2627                cout << "gid=" << gid << endl;
2628        }       
2629        fclose(element_ID_in);
2630        return;
2631
2632        int buffer_base = 0;
2633        int block_base = 0;
2634        int buffer_pos = 0;
2635        int block_pos = 0;
2636        int errpos = 0;
2637        int chars_avail = 0;
2638        int check_pos = 0;
2639        int chars_read = 0;
2640 
2641        //////////////////////////////////////////////////////////////////////////////////////////
2642    // Buffer Management
2643    //////////////////////////////////////////////////////////////////////////////////////////
2644                //      BitBlock buf[(BUFFER_SIZE)/sizeof(BitBlock)];
2645                //      uint8_t * src_buffer = (uint8_t *)buf + COPYBACK_SIZE;
2646
2647                #ifdef STL_ALIGNED_VECTOR
2648                        std::vector<uint8_t, AAllocator<uint8_t> > src_buffer;
2649                        src_buffer.reserve(BUFFER_SIZE);
2650                #else
2651                        uint8_t * COPYBACK;
2652                        uint8_t * src_buffer;
2653                        ALLOC_STATIC_ALIGNED_BYTE_BUFFER_WITH_COPYBACK(COPYBACK, src_buffer);
2654                #endif
2655  /*
2656  BytePack buf[(BUFFER_SIZE+BLOCK_SIZE+LOOKAHEAD_SIZE*2)/sizeof(SIMD_type)];
2657
2658  char * srcbuf = ((char *) buf) + LOOKAHEAD_SIZE;
2659  buffer_base = buf_pos;
2660  source = srcbuf;
2661  */
2662  chars_read = fread((void *)&src_buffer[0], 1, SEGMENT_SIZE, infile);
2663  chars_avail = chars_read;
2664  if (chars_avail > BUFFER_SIZE) chars_avail = SEGMENT_SIZE;
2665
2666  if(chars_read<4){
2667    fprintf(stderr,"File is too short. Not well formed.\n");
2668    exit(-1);
2669  }
2670
2671  Entity_Info * e = new Entity_Info;
2672  e->AnalyzeSignature((unsigned char *)&src_buffer[0]);
2673
2674  if (e->code_unit_base == ASCII) {
2675
2676    XML_Decl_Parser<ASCII> decl_parser((unsigned char *)&src_buffer[0]);
2677
2678    decl_parser.ReadXMLInfo(*e);
2679
2680    if (e->code_unit_size != SingleByte || (e->has_encoding_decl && (!at_UTF_8(e->encoding)))){
2681        fprintf(stderr,"Sorry, this xmlwf demo only works for UTF-8.\n");
2682        exit(-1);
2683    }
2684  }
2685  else {
2686    fprintf(stderr,"Sorry, this xmlwf demo does not process EBCDIC.\n");
2687        exit(-1);
2688  }
2689
2690  if (e->content_start != 0) {
2691        memmove(&src_buffer[0], &src_buffer[e->content_start], chars_read - e->content_start);
2692        buffer_pos = e->content_start;
2693//      buffer_base = buffer_pos;
2694        if ((chars_avail-e->content_start) < SEGMENT_SIZE) {
2695                        chars_read = chars_avail - e->content_start + fread(&src_buffer[chars_avail-e->content_start], 1, e->content_start, infile);
2696                        chars_avail = chars_read;
2697                }
2698                if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
2699  }
2700
2701        //////////////////////////////////////////////////////////////////////////////////////////
2702        // Read OVERLAP bytes to support post processing validation lookahead.
2703        //////////////////////////////////////////////////////////////////////////////////////////
2704        chars_read = chars_avail + fread(&src_buffer[chars_avail], 1, LOOKAHEAD_SIZE, infile);
2705        chars_avail = chars_read;
2706        if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
2707
2708  Parse_refs parse_refs;
2709  Validate_Elem_Vec validate_Elem_Vec;
2710  Parse_tags parse_tags;
2711  Classify_bytes_Validate_utf8 classify_bytes_Validate_utf8;
2712  Parse_CtCDPI parse_CtCDPI;
2713  Do_check_streams do_check_streams;
2714  Form_Length_Group_Bitstreams form_Length_Group_Bitstreams;
2715  Validate_xml_names validate_xml_names;
2716  Compute_Hash_Value_Bitstream compute_Hash_Value_Bitstream;
2717  Add_scope_streams add_scope_streams;
2718
2719
2720        #ifndef STL_ALIGNED_VECTOR
2721        matcher.setSrc((char *)&src_buffer[0]);
2722        #endif
2723
2724/* Full Buffers */
2725    int block_segment_num = 0;
2726    while (chars_avail >= SEGMENT_SIZE) {
2727      PERF_SEC_START(parser_timer);
2728      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
2729        cout << "loops" << ends;
2730                block_base = blk*BLOCK_SIZE;
2731        s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
2732     
2733               
2734  classify_bytes_Validate_utf8.do_block(basis_bits, lex, u8);
2735  add_scope_streams.do_block(lex, scope1);
2736  parse_CtCDPI.do_block(lex, marker, ctCDPI_Callouts, check_streams);
2737  parse_tags.do_block(lex, marker, tag_Callouts);
2738  parse_refs.do_block(lex, marker, ref_Callouts);
2739  validate_xml_names.do_block(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, check_streams);
2740  do_check_streams.do_block(marker, tag_Callouts, check_streams);
2741  form_Length_Group_Bitstreams.do_block(tag_Callouts);
2742  compute_Hash_Value_Bitstream.do_block(hash_data, basis_bits);
2743         
2744                tracker.StoreNewlines(lex.LF);
2745                cout << "post start" << endl;
2746//              postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
2747                postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
2748                vectoring(tag_Callouts,hash_data,(char *)&src_buffer[0],block_base);
2749                cout << "post done" << endl;
2750                #ifndef STL_ALIGNED_VECTOR
2751                matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
2752                #endif
2753                tracker.AdvanceBlock();
2754                cout << "loop" << endl;
2755      }
2756      #ifndef STL_ALIGNED_VECTOR
2757      matcher.StreamScan(chars_avail);
2758      matcher.Advance_buffer();
2759      #endif
2760      cout << "11111" << endl;
2761      PERF_SEC_END(parser_timer, chars_avail);
2762          cout << "here" << endl;
2763      int bytes_left = chars_read - chars_avail;
2764      //////////////////
2765      //element name buffer, for scanning element name backwards
2766      /////////////////
2767      memmove(&element_name_buffer[0],&src_buffer[SEGMENT_SIZE-ELEMENT_BUFFER_SIZE],ELEMENT_BUFFER_SIZE);
2768      cross_buffer_flag = 1;
2769     
2770      memmove(&src_buffer[0], &src_buffer[SEGMENT_SIZE], LOOKAHEAD_SIZE);
2771      chars_read = fread(&src_buffer[LOOKAHEAD_SIZE],1,SEGMENT_SIZE, infile) + LOOKAHEAD_SIZE;
2772      chars_avail = chars_read;
2773      cout << "here" << endl;
2774      if (chars_avail > SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
2775      buffer_pos += chars_avail;
2776      buffer_base = buffer_pos;
2777      block_segment_num++;
2778
2779  }
2780       
2781/* Final Partial Buffer */
2782    PERF_SEC_START(parser_timer);
2783
2784    block_pos = 0;
2785    int remaining = chars_avail;
2786
2787
2788
2789/* Full Blocks */
2790    while (remaining >= BLOCK_SIZE) {
2791          block_base = block_pos;
2792          s2p_do_block((BytePack *) &src_buffer[block_pos], basis_bits);
2793         
2794         
2795  classify_bytes_Validate_utf8.do_block(basis_bits, lex, u8);
2796  add_scope_streams.do_block(lex, scope1);
2797  parse_CtCDPI.do_block(lex, marker, ctCDPI_Callouts, check_streams);
2798  parse_tags.do_block(lex, marker, tag_Callouts);
2799  parse_refs.do_block(lex, marker, ref_Callouts);
2800  validate_xml_names.do_block(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, check_streams);
2801  do_check_streams.do_block(marker, tag_Callouts, check_streams);
2802  form_Length_Group_Bitstreams.do_block(tag_Callouts);
2803  compute_Hash_Value_Bitstream.do_block(hash_data, basis_bits);
2804         
2805          tracker.StoreNewlines(lex.LF);
2806          cout << "post start1" << endl;
2807         
2808//        postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
2809          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
2810          vectoring(tag_Callouts,hash_data,(char *)&src_buffer[0],block_base);
2811          cout << "post end2" << endl;
2812          #ifndef STL_ALIGNED_VECTOR
2813          matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
2814          #endif
2815          tracker.AdvanceBlock();
2816          block_pos += BLOCK_SIZE;
2817          remaining -= BLOCK_SIZE;
2818    }
2819    block_base = block_pos;
2820        #ifdef USE_ANY_CARRY_TEST
2821    if (remaining > 0 || parse_refs.carryQ.CarryTest(0, 6) || 0 || parse_tags.carryQ.CarryTest(0, 13) || classify_bytes_Validate_utf8.carryQ.CarryTest(0, 12) || parse_CtCDPI.carryQ.CarryTest(0, 19) || 0 || form_Length_Group_Bitstreams.carryQ.CarryTest(0, 16) || validate_xml_names.carryQ.CarryTest(0, 9) || 0 || add_scope_streams.carryQ.CarryTest(0, 2)) {
2822        #endif
2823          EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
2824          s2p_do_final_block((BytePack *) &src_buffer[block_pos], basis_bits, EOF_mask);
2825         
2826  classify_bytes_Validate_utf8.do_final_block(basis_bits, lex, u8, EOF_mask);
2827  add_scope_streams.do_final_block(lex, scope1, EOF_mask);
2828  parse_CtCDPI.do_final_block(lex, marker, ctCDPI_Callouts, check_streams, EOF_mask);
2829  parse_tags.do_final_block(lex, marker, tag_Callouts, EOF_mask);
2830  parse_refs.do_final_block(lex, marker, ref_Callouts, EOF_mask);
2831  validate_xml_names.do_final_block(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, check_streams, EOF_mask);
2832  do_check_streams.do_final_block(marker, tag_Callouts, check_streams, EOF_mask);
2833  form_Length_Group_Bitstreams.do_final_block(tag_Callouts, EOF_mask);
2834  compute_Hash_Value_Bitstream.do_final_block(hash_data, basis_bits, EOF_mask);
2835          cout << "post start3" << endl;
2836//        postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
2837          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
2838          vectoring(tag_Callouts,hash_data,(char *)&src_buffer[0],block_base);
2839          cout << "post end3" << endl;
2840          #ifndef STL_ALIGNED_VECTOR
2841      matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
2842          #endif
2843          tracker.AdvanceBlock();
2844        #ifdef USE_ANY_CARRY_TEST
2845    }
2846    #endif
2847    buffer_pos += chars_avail;
2848    buffer_base = buffer_pos;
2849        #ifndef STL_ALIGNED_VECTOR
2850    matcher.StreamScan(chars_avail);
2851    matcher.Advance_buffer();
2852//    tracker.Advance_buffer();
2853
2854   
2855    if (matcher.depth != 0) {
2856      fprintf(stderr, "tag matching error (depth %i) at position %i\n", matcher.depth, buffer_base);
2857      exit(-1);
2858     
2859     
2860    }
2861    #endif
2862    PERF_SEC_END(parser_timer, chars_avail);
2863//  print_GIDS();
2864//    pbgs_symbol_table.Print_Symbol_Table_Distribution();
2865}
2866
2867
2868
2869int
2870main(int argc, char * argv[]) {
2871        char * infilename, * outfilename;
2872        FILE *infile, *outfile;
2873        struct stat fileinfo;
2874
2875        if (argc < 2) {
2876                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
2877                exit(-1);
2878        }
2879
2880        infilename = argv[1];
2881        stat(infilename, &fileinfo);
2882        infile = fopen(infilename, "rb");
2883        if (!infile) {
2884                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
2885                exit(-1);
2886        }
2887
2888        if (argc < 3) outfile = stdout;
2889        else {
2890                outfilename = argv[2];
2891                outfile = fopen(outfilename, "wb");
2892                if (!outfile) {
2893                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
2894                        exit(-1);
2895                }
2896        }
2897
2898//      PERF_SEC_BIND(1);
2899
2900        PERF_SEC_INIT(parser_timer);
2901
2902        do_process(infile, outfile);
2903       
2904#if DEBUG
2905print_gid_vec();
2906#endif
2907        //cout << "validate start" << endl;
2908        validate();
2909
2910        PERF_SEC_DUMP(parser_timer);
2911
2912        PERF_SEC_DESTROY(parser_timer);
2913
2914        fclose(infile);
2915        fclose(outfile);
2916
2917        printf ("Done procressing\n");
2918        return(0);
2919}
Note: See TracBrowser for help on using the repository browser.