source: proto/xmlschema/validation_template_onevec_shiporder.cpp @ 3538

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

shiporder tests

File size: 65.7 KB
Line 
1
2#include <simd-lib/bitblock.hpp>
3#include <simd-lib/carryQ.hpp>
4#include <simd-lib/pabloSupport.hpp>
5
6#define LocalCarryDeclare(name, count)\
7CarryArray<count, 0> name;\
8
9#define assert_0_error(errkind, errstrm)
10
11BitBlock EOF_mask = simd<1>::constant<1>();
12
13//#define USE_FUNCTION_TEMPLATES
14//#define TEMPLATED_SIMD_LIB
15
16//#define BLOCK_SIZE (sizeof(SIMD_type) * 8)
17//#define SEGMENT_BLOCKS 12
18//#define BUFFER_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
19//#define OVERLAP_BUFSIZE 2*(sizeof(SIMD_type))
20
21#define VECTOR_WIDTH 8
22#define VECTOR_TYPE (char)
23
24//#define DEBUG 1
25
26#define DATATYPE 1
27
28#define CONTENT_MODEL 1
29
30
31#include <stdio.h>
32#include <stdlib.h>
33#include <errno.h>
34#include <sys/types.h>
35#include <sys/stat.h>
36#include <limits.h>
37
38#include <simd-lib/s2p.hpp>
39#include <simd-lib/buffer.hpp>
40#include <simd-lib/bitblock_iterator.hpp>
41#include <simd-lib/perflib/perfsec.h>
42
43//#include "../lib/lib_simd.h"
44#include "../symtab/pbgs_identity_symbol_table.h"
45
46#include <stack>
47#include <map>
48#include <vector>
49
50#include <queue>
51#include <string>
52
53typedef long ScanBlock;
54typedef BytePack BitBlock;
55
56using namespace std;
57
58//#include "../lib/carryQ.h"
59#include <xmldecl.h>
60//#include "xml_error.c"
61//#include "xmldecl.c"
62#include <namechars.h>
63#include <LineColTracker.hpp>
64#include <XMLTestSuiteError.h>
65
66// Define the mappings for pablo.assert_0(strm, errkind) statements which
67// compile to the the form assert_0_error(errkind, strm)
68#include <ErrorTracker.h>
69
70ErrorTracker error_tracker;
71#define assert_0_error(errkind, errstrm) error_tracker.NoteError(errkind, errstrm);
72
73#ifndef STL_ALIGNED_VECTOR
74#include <TagMatcher.hpp>
75#endif
76
77#ifdef STL_ALIGNED_VECTOR // experimental, comment out TagMatcher code to use STL aligned memory vector
78#warning "Compiling with experimental STL_ALIGNED_VECTOR."
79#include <vector>
80#include <simd-lib/stl_aligned_allocator.hpp>
81#endif
82
83#ifdef BUFFER_PROFILING
84    BOM_Table * parser_timer;
85#elif PAPI
86                #define PAPI_EVENTS_COUNT 2
87                int PAPI_EVENTS[PAPI_EVENTS_COUNT] = {PAPI_TOT_CYC, PAPI_BR_MSP};       
88    CC * parser_timer;
89#else
90    void * parser_timer;
91#endif
92
93//////////////////////////////////////////////////////////////////////////////////////////
94// Buffer Management // WARNING: Do Not update #defines. Results in TagMatcher errors.
95//////////////////////////////////////////////////////////////////////////////////////////
96#define PADDING_BLOCKS 0
97#define PADDING_SIZE (BLOCK_SIZE * PADDING_BLOCKS)
98#define COPYBACK_BLOCKS 2
99#define COPYBACK_SIZE (BLOCK_SIZE * COPYBACK_BLOCKS)
100#define LOOKAHEAD_BLOCKS 1
101#define LOOKAHEAD_SIZE (BLOCK_SIZE * LOOKAHEAD_BLOCKS)
102#define SEGMENT_BLOCKS  12 // WARNING: TagMatcher.hpp causes xmlconf test suite failures for SEGMENT_BLOCKS < 3.
103#define SEGMENT_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
104#define BUFFER_SIZE (COPYBACK_SIZE + SEGMENT_SIZE + LOOKAHEAD_SIZE + PADDING_SIZE)
105
106
107
108//int block_base=0;
109//int buffer_base=0;
110int buffer_last;
111FILE *gid_writein;
112#define ELEMENT_BUFFER_SIZE 30
113char element_name_buffer[ELEMENT_BUFFER_SIZE];
114int cross_buffer_flag = 0;
115//char * source;
116LineColTracker tracker;
117
118#define CONTENT_BUFFER_SIZE BLOCK_SIZE
119char content_buffer[CONTENT_BUFFER_SIZE];
120char content_lookahead_buffer[CONTENT_BUFFER_SIZE];
121int content_buffer_pos = 0;
122int content_carry = 0;
123char gid;
124int content_start_carry = 0;
125
126#define CONTENT_INDEX 13
127
128static inline int cfzl(long x){
129        unsigned long ux = x;
130        if (x<0){
131                ux = ULONG_MAX + x + 1;
132        }
133        if (ux==0)
134                return 8*sizeof(long);
135        int n;
136        n = 0;
137        while (1){
138                if ((ux%2) == 1){
139                        if(n==64){
140//                              cout << ux <<endl;
141                        }
142                        return n;               
143                }
144                n ++;
145                ux = ux >> 1;
146                //cout << "x = " << x << endl;
147        } 
148}
149
150static inline void print_gid_vec();
151/*
152static inline int cfzl(long x){
153 if (x ==0)
154  return 32;
155 int n=0;
156 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
157 if ((x & 0xFF000000) == 0){ n = n +  8; x = x <<  8;} // 8 left bits are 0
158 if ((x & 0xF0000000) ==0){ n = n +  4; x = x <<  4;} // 4 left bits are 0
159 if ((x & 0xC0000000) == 0){ n =n +  2, x = x <<  2;}  // 110000....0 2 left bits are zero
160 if ((x & 0x80000000) == 0){n = n +  1, x = x <<  1;} // first left bit is zero
161 return n;
162
163}
164*/
165static inline void ReportError(const char * error_msg, int error_pos_in_block) {
166  int error_line, error_column;
167  tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
168  fprintf(stderr, "%s at line %i, column %i\n", error_msg, error_line, error_column);
169}
170/*
171class ErrorTracker {
172public:
173    ErrorTracker() { noted_pos_in_block = -1;}
174
175    inline void NoteError(const char * error_msg, BitBlock err_strm) {
176      int pos_in_block = count_forward_zeroes(err_strm);
177      if ((noted_pos_in_block == -1) || (noted_pos_in_block > pos_in_block)) {
178        noted_pos_in_block = pos_in_block;
179        noted_error = error_msg;
180      }
181    }
182
183    inline void If_Error_Report_First() {
184      if (noted_pos_in_block > -1) {
185              int error_line, error_column;
186              ReportError(noted_error, noted_pos_in_block);
187              exit(-1);
188      }
189    }
190
191private:
192  const char * noted_error;
193  int noted_pos_in_block;
194};
195*/
196
197
198//BitBlock EOF_mask = simd_const_1(1);
199
200//ErrorTracker error_tracker;
201BitBlock elem_starts;
202int previous_block_last_elem_start;
203BytePack hashvalues[2];
204
205vector <int> gids;
206PBGSIdentitySymbolTable pbgs_symbol_table;
207
208#define MAX_COUNT 128
209vector <char> gid_vec[MAX_COUNT];
210int current_depth = 0;
211vector <int> pre_index;
212
213stack <vector<char>* > elem_vec_stack;
214map<char, vector<char>* > elem_vec_map;
215
216@global
217
218#include <simd-lib/transpose.hpp>
219#include <post_process.hpp>
220
221static inline int ScanBackwardPos(BitBlock * block, int pos)
222{
223//      cout << "pos " << pos << endl;
224    BitBlock s = block[0];
225    if (bitblock::any(block[0])){
226//      print_register("zero",block[0]);
227//      print_register("t",simd_not(simd<128>::sll(simd<1>::constant<1>(), convert(pos))) );
228        }
229    BitBlock temp = simd_and( s, simd_not(simd<128>::sll(simd<1>::constant<1>(), convert(pos))) );
230//      print_register("zero",simd_not(simd<128>::sll(simd<1>::constant<1>());
231//              print_register("temp",temp);
232    if (bitblock::any(temp))
233    {
234        // sizeof (BitBlock)*8 - cbzl( s & ~(~0 << pos)) - 1;
235//      cout << "block_size" << BLOCK_SIZE << endl;
236        return BLOCK_SIZE - count_reverse_zeroes(temp) - 1;
237    }
238    else
239    {
240        //handle boundary case
241        return previous_block_last_elem_start - 1;
242    }
243}
244
245static inline int StreamScan(ScanBlock * stream, int blk_count, int ProcessPos(int)) {
246        int blk;
247        int block_pos = 0;
248        for (blk = 0; blk < blk_count; blk++) {
249                ScanBlock s = stream[blk];
250                while(s) {
251                        int code = (ProcessPos(cfzl(s) + block_pos));
252                        if (code) return code;
253                        s = s & (s-1);  // clear rightmost bit.
254                }
255                block_pos += 8 * sizeof(ScanBlock);
256        }
257        return 0;
258}
259
260static inline int compute_hash_value2(char *str,int lgth){
261        int hash = 5381;
262    int c;
263//      while (c = *str++){
264        for (int i = 0;i<lgth;i++){
265                c=*str++; 
266        hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
267    }
268
269    return hash;
270}
271
272static inline int compute_hash_value (int lgth, int start)
273{
274    unsigned int offset_bit = start + 128;
275    uint64_t stream = *((uint64_t*)(((uint32_t*)hashvalues)+(offset_bit>>5)));
276    return stream >> (offset_bit & 0x1F) & ~(~0 << lgth);
277}
278
279static inline void print_basis_bits(Basis_bits & basis_bits){
280        print_register("bit0:",basis_bits.bit_0);
281        print_register("bit1:",basis_bits.bit_1);
282        print_register("bit2:",basis_bits.bit_2);
283        print_register("bit3:",basis_bits.bit_3);
284        print_register("bit4:",basis_bits.bit_4);
285        print_register("bit5:",basis_bits.bit_5);
286        print_register("bit6:",basis_bits.bit_6);
287        print_register("bit7:",basis_bits.bit_7);                                       
288}
289/*
290template <int L>
291static inline int ElemEnd_grouping(int pos) {
292    int end = block_base + pos;
293    int start = end - L;
294    int hashvalue = compute_hash_value(L, start - block_base);
295    int gid = pbgs_symbol_table.Lookup_or_Insert_Name<L>(source + start, hashvalue);
296    gids.push_back(gid);
297#if DEBUG
298    char* symbol = new char[L+1];
299    strncpy ( symbol, source + start, L );
300    symbol[L] ='\0';
301    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 );
302    delete symbol; symbol = 0;
303#endif
304    return gid;
305}
306
307template<>
308inline int ElemEnd_grouping<17>(int pos) {
309    int end = block_base + pos;
310    int start = ScanBackwardPos (&elem_starts, pos) + block_base;
311    int lgth = end - start;
312    int hashvalue = compute_hash_value(lgth, start - block_base);
313    int gid = 0;
314
315//    if (lgth < 32)
316//    {
317//      gid = pbgs_symbol_table.Lookup_or_Insert_Name_32(source + start, hashvalue, lgth);
318//    }
319//    else
320    {
321        gid = pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
322    }
323    gids.push_back(gid);
324#if DEBUG
325    char* symbol = new char[lgth+1];
326    strncpy ( symbol, source + start, lgth );
327    symbol[lgth] ='\0';
328    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);
329#endif
330    return gid;
331}
332*/
333
334static inline char ElemEnd_grouping(char *source,int block_base,int pos) {
335    int end = block_base + pos;
336    int start = ScanBackwardPos(&elem_starts, pos) + block_base;
337    ///////////////////////
338    //start could be negitive
339    //the element name falls in two buffers
340    ///////////////////////
341    char *name = source + start;
342    char name_buffer[50];
343   
344    if (start<0){
345#ifdef DEBUG
346            fprintf(gid_writein,"name_buffer %s\n",element_name_buffer);
347#endif
348        memmove (&name_buffer[0],&element_name_buffer[ELEMENT_BUFFER_SIZE+start],-start);       
349        memmove (&name_buffer[-start],&source[0],50+start);
350        name = name_buffer;
351        //fprintf (gid_writein,"name_buffer %s",name);
352#ifdef DEBUG
353        fprintf(gid_writein,"name_buffer %s\n",name);
354#endif
355    }
356//    cout << end << "  " << start << endl;
357    int lgth = end - start;
358//    int hashvalue = compute_hash_value(lgth,start-block_base);
359        int hashvalue = compute_hash_value2(name,lgth);
360    char gid = 0;
361
362
363//    if (lgth < 32)
364//    {
365//      gid = pbgs_symbol_table.Lookup_or_Insert_Name_32(source + start, hashvalue, lgth);
366//    }
367//    else
368
369        switch (lgth)
370    {
371    case 1:
372        gid = pbgs_symbol_table.Lookup_or_Insert_Name<1>(name, hashvalue);
373        break;
374    case 2:
375        gid = pbgs_symbol_table.Lookup_or_Insert_Name<2>(name, hashvalue);
376        break;
377    case 3:
378        gid = pbgs_symbol_table.Lookup_or_Insert_Name<3>(name, hashvalue);
379        break;
380    case 4:
381        gid = pbgs_symbol_table.Lookup_or_Insert_Name<4>(name, hashvalue);
382        break;
383    case 5:
384        gid = pbgs_symbol_table.Lookup_or_Insert_Name<5>(name, hashvalue);
385        break;
386    case 6:
387        gid = pbgs_symbol_table.Lookup_or_Insert_Name<6>(name, hashvalue);
388        break;
389    case 7:
390        gid = pbgs_symbol_table.Lookup_or_Insert_Name<7>(name, hashvalue);
391        break;
392    case 8:
393        gid = pbgs_symbol_table.Lookup_or_Insert_Name<8>(name, hashvalue);
394        break;
395    case 9:
396        gid = pbgs_symbol_table.Lookup_or_Insert_Name<9>(name, hashvalue);
397        break;
398    case 10:
399        gid = pbgs_symbol_table.Lookup_or_Insert_Name<10>(name, hashvalue);
400        break;
401    case 11:
402        gid = pbgs_symbol_table.Lookup_or_Insert_Name<11>(name, hashvalue);
403        break;
404    case 12:
405        gid = pbgs_symbol_table.Lookup_or_Insert_Name<12>(name, hashvalue);
406        break;
407    case 13:
408        gid = pbgs_symbol_table.Lookup_or_Insert_Name<13>(name, hashvalue);
409        break;
410    case 14:
411        gid = pbgs_symbol_table.Lookup_or_Insert_Name<14>(name, hashvalue);
412        break;
413    case 15:
414        gid = pbgs_symbol_table.Lookup_or_Insert_Name<15>(name, hashvalue);
415        break;
416    case 16:
417        gid = pbgs_symbol_table.Lookup_or_Insert_Name<16>(name, hashvalue);
418        break;
419    default:
420        gid = pbgs_symbol_table.Lookup_or_Insert_Name(name, hashvalue, lgth);
421        break;
422    }
423/*
424    {
425        gid = (char)pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
426    }
427*/
428    gids.push_back(gid);
429#ifdef DEBUG
430    char* symbol = new char[lgth+1];
431    strncpy ( symbol, source + start, lgth );
432    symbol[lgth] ='\0';
433//    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);
434    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);
435#endif
436    return gid;
437}
438
439static inline int print_source(char* source, int lgth ,int seg){
440        char ret[128];
441        int j;
442        for (int i=0;i<seg;i++){
443                for(j=0;j<lgth;j++){
444                        if(source[i*lgth+j]!='\n')
445                                ret[j] = source[i*lgth + j];
446                        else
447                                ret[j] = ' ';
448                }
449                ret[j] = '\0';
450//              cout << ret << endl;
451        }
452        return 0;
453}
454
455Validate_content_5 validate_content_5;
456
457static inline void validate_data_type(int char_aval, int gid_index){
458        struct Lex lex;
459        struct Output output;
460        Classify_bytes_Validate_utf8 classify_bytes_Validate_utf8;
461        U8 u8;
462        Basis_bits temp_basis_bits;
463//      Validate_content_5 validate_content_5;
464       
465        if(char_aval == BLOCK_SIZE){
466                s2p_do_block((BytePack*)(&content_buffer), temp_basis_bits);
467#ifdef DEBUG
468                print_basis_bits(temp_basis_bits);
469#endif
470                classify_bytes_Validate_utf8.do_block(temp_basis_bits,lex,u8);
471#ifdef  DEBUG
472                cout << content_buffer << endl;
473               
474                print_register("digit:",lex.Digit);
475                print_register("dot:",lex.Dot);
476                print_register("namescan:",lex.NameScan);
477                print_register("P_N:",lex.P_H_sign);
478                print_register("content_end:",lex.content_end);
479#endif
480                validate_content_5.do_block(lex,output);
481#ifdef DEBUG
482                print_register("output:",output.matches);
483                print_register("output.tem:",output.tem);
484#endif
485        }else{
486                int remaining = BLOCK_SIZE -char_aval;
487                BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
488                s2p_do_final_block((BytePack*)(&content_buffer), temp_basis_bits,EOF_mask);
489                classify_bytes_Validate_utf8.do_final_block(temp_basis_bits,lex,u8,EOF_mask);
490                validate_content_5.do_final_block(lex,output,EOF_mask);
491        }
492}
493
494//template <int L>
495static inline int StreamScanLengthGrouping(char *source,int block_base,ScanBlock * stream, ScanBlock * stream2, int blk_count,ScanBlock * stream3,ScanBlock * stream4) {
496    int blk;
497    int block_pos = 0;
498//    cout << "cfzl():" << cfzl() << endl;
499//      long test = 6;
500//      test = (test & (test - 1));
501//      cout << "test" << endl;
502    for (blk = 0; blk < blk_count; blk++) {
503//      cout << "blk:" << blk << endl;
504   
505                ScanBlock s = stream[blk];
506                ScanBlock s2 = stream2[blk];
507                ScanBlock s3 = stream3[blk];
508                ScanBlock s4 = stream4[blk];
509                int end_content;
510                int start_content;
511                int content_lgth;
512                int content_aval = CONTENT_BUFFER_SIZE - content_buffer_pos;
513               
514//              cout << "block_pos " << block_pos <<endl;
515#ifdef DATATYPE         
516                if (content_start_carry == 1 && gid == CONTENT_INDEX){
517//                      cout << "****" << endl;
518                        start_content = cfzl(s3) + block_pos;
519                                        if (cfzl(s3) != 8*sizeof(ScanBlock)){
520                                                content_start_carry = 0;
521                                        }
522                                       
523                                        end_content = cfzl(s4) + block_pos;
524                                        while(end_content < start_content){
525                                                s4 = s4 & (s4-1);
526                                                end_content = cfzl(s4) + block_pos;
527                                        }
528        //                      cout << "cfzl" << cfzl(s4) << " " <<sizeof(ScanBlock) <<endl;
529                                        if(cfzl(s4)==8*sizeof(ScanBlock)){
530                                                content_carry = 1;
531        //                              cout << "end_of_block" << endl;
532                                        }
533                                        content_lgth = end_content - start_content;
534//                                      cout << end_content << " " << start_content <<endl;
535//                                      cout << "lgth: " << content_lgth << endl;
536                                        content_aval = CONTENT_BUFFER_SIZE - content_buffer_pos;
537                                        int full_content = 0;
538                                        int buffer_full = 0;
539                                        if(content_carry != 1 && gid == CONTENT_INDEX){
540                                                if(content_aval > content_lgth-2 && content_lgth > 2 && gid == CONTENT_INDEX){
541                                                        memmove(&content_buffer[content_buffer_pos],&source[start_content+block_base+1],content_lgth-2);
542                                                        char temp = '#';
543                                                        content_buffer_pos += content_lgth-2;
544                                                        memmove(&content_buffer[content_buffer_pos],&temp,1);
545                                                        content_buffer_pos ++;
546//                                                      cout << "@@" <<endl;
547//                                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_lgth-2 << endl;
548                                                }else if(gid == CONTENT_INDEX){
549                                                        memmove(&content_buffer[content_buffer_pos],&source[start_content+block_base+1],content_aval);
550                                                        full_content = 1;
551                                               
552                                                        content_buffer_pos += content_aval;
553                                                        memmove(&content_lookahead_buffer[0],&source[start_content+block_base+1+content_aval],content_lgth-2-content_aval);
554//                                                      cout << "@@@" <<endl;
555//                                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;       
556                                                        content_buffer_pos = content_lgth-2-content_aval;
557                                                        buffer_full = 1;
558                                                }
559                                        }else if(gid == CONTENT_INDEX){
560                                                if(content_aval > content_lgth-1 && content_lgth > 1 && gid == CONTENT_INDEX){
561//                                                      cout << "@" << endl;
562//                                              cout << content_aval << "   " << content_lgth << endl;
563                                                memmove(&content_buffer[content_buffer_pos],&source[start_content+block_base+1],content_lgth-1);
564//                                              printf("%.*s\n",content_lgth-1,&content_buffer[content_buffer_pos]);
565                                                        content_buffer_pos += content_lgth-1;
566//                                                      full_content = 1;       
567                                                }else if(content_aval < content_lgth-1 && gid == CONTENT_INDEX){
568//                                                      cout << "@@@@" << endl;
569//                                                      cout << content_aval << "   " << content_lgth << endl;
570                                                        memmove(&content_buffer[content_buffer_pos],&source[start_content+block_base+1],content_aval);
571                                               
572                                                        content_buffer_pos += content_aval;
573                                                        memmove(&content_lookahead_buffer[0],&source[start_content+block_base+1+content_aval],content_lgth-1-content_aval);
574        //                                              full_content = 1;
575                                                        content_buffer_pos = content_lgth-1-content_aval;
576                                                        buffer_full = 1;
577                                                }
578                                        }
579                                        if (buffer_full == 1){
580        //                              cout << "buffer_full" << endl;
581        //                                  content_buffer[CONTENT_BUFFER_SIZE-1] = '\0';
582        //                              cout << content_buffer << endl << endl;
583                                                validate_data_type(CONTENT_BUFFER_SIZE,5);
584                                                memmove(&content_buffer[0],&content_lookahead_buffer[0],content_buffer_pos);
585                                                if (full_content == 1){
586                                                        char temp = '#';
587                                                        memmove(&content_buffer[content_buffer_pos],&temp,1);
588                                                        content_buffer_pos ++;
589                                                        full_content = 0;
590                                                }
591                                                buffer_full = 0;
592                                        }
593                }else if (content_carry == 1 && gid == CONTENT_INDEX){
594                end_content = cfzl(s4) + block_pos;
595                start_content = block_pos-1;
596                content_lgth = end_content-block_pos;
597                content_aval = CONTENT_BUFFER_SIZE - content_buffer_pos;
598                if (cfzl(s4) != 8*sizeof(ScanBlock)){
599                        content_carry = 0;
600                        s4 = s4 & (s4-1);
601                }
602                int buffer_full = 0;
603                if (content_carry !=1){
604                                if(content_aval > content_lgth-1 && content_lgth > 1){
605//                                      cout << "##" << endl;
606        //                      cout << "lgth " << content_lgth << endl;
607                                        memmove(&content_buffer[content_buffer_pos],&source[block_pos+block_base],content_lgth-1);
608//                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;
609//                                      cout << "content_lgth " << content_lgth <<endl;
610//                                      printf("%.*s\n",content_lgth-1+content_buffer_pos,content_buffer);
611                                        content_buffer_pos += content_lgth-1;
612                                        char temp = '#';
613                                        memmove(&content_buffer[content_buffer_pos],&temp,1);
614                                        content_buffer_pos ++;
615        //                      content_buffer[content_buffer_pos] = '\0';
616        //                      cout << "^^^" << endl;
617        //                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_lgth-1 << endl;
618        //                      cout << content_buffer << endl;
619                                }else if (content_lgth == 0){
620                                        content_buffer[content_buffer_pos-1] = '#';
621                                }else if (content_aval > 0 && content_lgth == 1){
622//                                      cout << "###" << endl;
623                                        content_buffer[content_buffer_pos] = '#';
624                                        content_buffer_pos++;
625                                        if(content_buffer_pos == CONTENT_BUFFER_SIZE){
626                                                validate_data_type(CONTENT_BUFFER_SIZE,5);
627                                                content_buffer_pos = 0;
628                                        }
629                                }else if (content_aval <= content_lgth-1){
630//                                      cout << "@@@@@@@@@@@@@@@@@@" << endl;
631                                        memmove(&content_buffer[content_buffer_pos],&source[block_pos+block_base],content_aval);
632                                        memmove(&content_lookahead_buffer[0],&source[block_pos+block_base+content_aval],content_lgth-1-content_aval);
633//                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;
634//                                      cout << "content_lgth " << content_lgth <<endl;
635//                                      printf("%.*s\n",content_aval,&content_buffer[content_buffer_pos]);
636                                        content_buffer_pos = content_lgth-1-content_aval;
637        //                              content_buffer[CONTENT_BUFFER_SIZE-1] = '\0';
638        //                              cout << content_buffer << endl << endl;
639                                        validate_data_type(CONTENT_BUFFER_SIZE,5);
640                                        memmove(&content_buffer[0],&content_lookahead_buffer[0],content_buffer_pos);
641                                        if (content_lgth-1 < CONTENT_BUFFER_SIZE){
642                                                content_buffer[content_buffer_pos] = '#';
643                                                content_buffer_pos ++;
644                                        }
645                                }
646                }else if(gid == CONTENT_INDEX){
647                        if(content_aval > content_lgth){
648//                                      cout << "##*" << endl;
649//                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;
650//                                      cout << "content_lgth " << content_lgth <<endl;
651                                        memmove(&content_buffer[content_buffer_pos],&source[block_pos+block_base],content_lgth);
652//                                      printf("%.*s\n",content_lgth+content_buffer_pos,content_buffer);
653                                        content_buffer_pos += content_lgth;
654                                }else if (content_aval <= content_lgth && gid == CONTENT_INDEX){
655//                                      cout << "@@@@@@@@@@@@@@@@@@*" << endl;
656                                        memmove(&content_buffer[content_buffer_pos],&source[block_pos+block_base],content_aval);
657                                        memmove(&content_lookahead_buffer[0],&source[block_pos+block_base+content_aval],content_lgth-content_aval);
658//                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;
659//                                      cout << "content_lgth " << content_lgth <<endl;
660//                                      printf("%.*s\n",content_aval,&content_buffer[content_buffer_pos]);
661                                        content_buffer_pos = content_lgth-content_aval;
662                                        validate_data_type(CONTENT_BUFFER_SIZE,5);
663                                        memmove(&content_buffer[0],&content_lookahead_buffer[0],content_buffer_pos);
664                                }                       
665                }
666            }
667#endif
668//              print_source(&source[block_base],sizeof(ScanBlock)*8,2);
669//              print_register("start_content:",((BitBlock*)stream3)[0]);
670//              print_register("end_content:",((BitBlock*)stream4)[0]);
671//              cout << s << "  " << s2 << endl;
672//              print_register("s:",((BitBlock*)stream)[0]);
673                while(s | s2) {
674//                      cout << "cfzl(s):" << cfzl(s)<<endl;
675                    int end_pos = cfzl(s) + block_pos;
676//                  cout << "s2 " << s2 << endl;
677                    int end_tag = cfzl(s2) + block_pos;
678//              cout << "cfzl(s):" << cfzl(s)<<endl;
679//              cout << "cfzl(s2):" << cfzl(s2)<<endl;
680//                      cout << (end_tag < end_pos && s2 != 0)<< "||" <<(s == 0 && s2 != 0)  << endl;
681                        if ((end_tag < end_pos && s2 != 0) | (s == 0 && s2 != 0)){
682//                      cout << "here" << endl;
683//                      cout << "closing tag" << endl;
684//                      cout << "endtag:" << end_tag << " " << end_pos<<endl;
685//                      cout << "1"<< endl;
686//                      cout << elem_vec_stack.size()<<endl;
687//                      cout << "2" << endl;
688//                      cout << elem_vec_stack.top()<<endl;
689                                if(!(gid_vec[current_depth].empty())){
690//                                      if(gid_vec.back() != 0){
691                                                gid_vec[current_depth].push_back(0);
692                                                if(current_depth !=0){
693                                                        current_depth = pre_index.back();
694                                                        pre_index.pop_back();
695#ifdef DEBUG
696                                                        fprintf (gid_writein,"%d\n",current_depth);
697#endif
698                                                        gid_vec[current_depth].push_back(0);
699                                                }
700//                                      }
701                                }
702//                              cout << "before" << s2 << endl;
703                                s2 = s2 & (s2 - 1);
704//                              cout << "after" << s2 << endl;
705//                              cout << "s2 = " << s2 << endl;
706                }else{
707//                      cout << " end_pos == " << end_pos<<endl;
708//                      cout << " end_tag_pos == " << end_tag << endl;
709                        gid = ElemEnd_grouping(source,block_base,end_pos);
710#ifdef DATATYPE
711//                      printf("%d\n",int(gid));
712                        if (gid == CONTENT_INDEX){
713//                              cout << "source : ";
714//                              printf("%.*s\n",sizeof(ScanBlock)*8,&source[block_base]);
715                                        start_content = cfzl(s3) + block_pos;
716                                        while(start_content < end_pos){
717                                                s3 = s3 & (s3-1);
718                                                start_content = cfzl(s3) + block_pos;
719                                        }
720                                        if (cfzl(s3) == 8*sizeof(ScanBlock)){
721                                                content_start_carry = 1;
722                                        }
723                                        if (content_start_carry != 1){
724                //                      cout << "end_pos " << end_pos <<endl;
725                //                      char temp[20];
726                //                      memmove(temp,&source[end_pos+block_base],20);
727                //                      cout << "source: " << temp << endl;
728                                                //cout << "start_content " << start_content << endl;
729                                       
730                                                end_content = cfzl(s4) + block_pos;
731                                                while(end_content < start_content){
732                                                        s4 = s4 & (s4-1);
733                                                        end_content = cfzl(s4) + block_pos;
734                                                }
735                //                      cout << "cfzl" << cfzl(s4) << " " <<sizeof(ScanBlock) <<endl;
736                                                if(cfzl(s4)==8*sizeof(ScanBlock)){
737                                                        content_carry = 1;
738                //                              cout << "end_of_block" << endl;
739                                                }
740                                                content_lgth = end_content - start_content;
741//                                              cout << end_content << " " << start_content <<endl;
742//                                              cout << "lgth: " << content_lgth << endl;
743                                                content_aval = CONTENT_BUFFER_SIZE - content_buffer_pos;
744                                                int full_content = 0;
745                                                int buffer_full = 0;
746                                                if(content_carry != 1 && gid == CONTENT_INDEX){
747                                                        if(content_aval > content_lgth-2 && content_lgth > 2 && gid == CONTENT_INDEX){
748                                                                memmove(&content_buffer[content_buffer_pos],&source[start_content+block_base+1],content_lgth-2);
749                                                                char temp = '#';
750                                                                content_buffer_pos += content_lgth-2;
751                                                                memmove(&content_buffer[content_buffer_pos],&temp,1);
752                                                                content_buffer_pos ++;
753                //                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << endl;
754//                                                              cout << "@@" <<endl;
755//                                                              cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_lgth-2 << endl;
756                                                        }else if(gid == CONTENT_INDEX){
757                                                                memmove(&content_buffer[content_buffer_pos],&source[start_content+block_base+1],content_aval);
758                                                                full_content = 1;
759                                               
760                                                                content_buffer_pos += content_aval;
761                                                                memmove(&content_lookahead_buffer[0],&source[start_content+block_base+1+content_aval],content_lgth-2-content_aval);
762//                                                              cout << "@@@" <<endl;
763//                                                              cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;       
764                                                                content_buffer_pos = content_lgth-2-content_aval;
765                                                                buffer_full = 1;
766                                                        }
767                                                }else if(gid == CONTENT_INDEX){
768                                                        if(content_aval > content_lgth-1 && content_lgth > 1 && gid == CONTENT_INDEX){
769//                                                              cout << "@" << endl;
770//                                                              cout << content_aval << "   " << content_lgth << endl;
771                                                                memmove(&content_buffer[content_buffer_pos],&source[start_content+block_base+1],content_lgth-1);
772//                                                              printf("%.*s\n",content_lgth-1+content_buffer_pos,content_buffer);
773                                                                content_buffer_pos += content_lgth-1;
774        //                                                      full_content = 1;
775                //                                      cout << content_carry << endl;
776                //                                      cout << content_buffer << endl << endl;
777                //                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE<< "            "<< content_lgth-1 << endl;             
778                                                        }else if(content_aval < content_lgth-1 && gid == CONTENT_INDEX){
779//                                                              cout << "@@@@" << endl;
780//                                                              cout << content_aval << "   " << content_lgth << endl;
781                                                                memmove(&content_buffer[content_buffer_pos],&source[start_content+block_base+1],content_aval);
782                                               
783                                                                content_buffer_pos += content_aval;
784                                                                memmove(&content_lookahead_buffer[0],&source[start_content+block_base+1+content_aval],content_lgth-1-content_aval);
785                //                                              full_content = 1;
786                //                                              cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;       
787                                                                content_buffer_pos = content_lgth-1-content_aval;
788                                                                buffer_full = 1;
789                                                        }
790                                                }
791                                                if (buffer_full == 1){
792                //                              cout << "buffer_full" << endl;
793                //                                  content_buffer[CONTENT_BUFFER_SIZE-1] = '\0';
794                //                              cout << content_buffer << endl << endl;
795                                                        validate_data_type(CONTENT_BUFFER_SIZE,5);
796                                                        memmove(&content_buffer[0],&content_lookahead_buffer[0],content_buffer_pos);
797                                                        if (full_content == 1){
798                                                                char temp = '#';
799                                                                memmove(&content_buffer[content_buffer_pos],&temp,1);
800                                                                content_buffer_pos ++;
801                                                                full_content = 0;
802                                                        }
803                                                        buffer_full = 0;
804                                                }
805                                        }
806                        }
807#endif                 
808//                      content_buffer[content_buffer_pos] = '\0';
809//                      cout << content_buffer << endl;
810                        if (s!=0){
811                                s = s & (s-1);  // clear rightmost bit.
812                        }
813                        //else{
814                        //      s2 = s2 & (s2 - 1);
815                        //}
816                                if (gid != 0){
817                                        gid_vec[current_depth].push_back(gid);
818#ifdef DEBUG
819                                        fprintf (gid_writein,"%d\n",current_depth);
820#endif
821                                        pre_index.push_back(current_depth);
822                                        current_depth = (int)gid;
823                                        gid_vec[current_depth].push_back(gid);
824#ifdef DEBUG
825                                        fprintf (gid_writein,"%d\n",current_depth);                     
826#endif
827                                }
828                }       
829                }
830                block_pos += 8 * sizeof(ScanBlock);
831//              print_gid_vec();
832    }
833    return 0;
834}
835
836void print_gid_vec(){
837        for (int j = 0; j < MAX_DEPTH; j++){
838                if(gid_vec[j].empty()){
839                        return;
840                }
841                for (int i = 0; i < gid_vec[j].size(); i++){
842                        cout << j << ":" << endl;
843                        cout << (int)gid_vec[j][i] << " ";
844                }
845        }
846        cout << endl;
847/*     
848        int i = 1;
849        int lst[256] = {0};
850        cout << elem_vec_map.size() << " vectors" << endl;
851        for (int i = 0;i < gids.size(); i++){
852                if (lst[gids[i]] == 0){
853                        cout << "gid: " << gids[i] << endl;
854                        lst[gids[i]] = 1;
855                        vector<char> *tmp = elem_vec_map[gids[i]];
856                        cout << "vector size:"<< (*tmp).size()<<endl;
857                        if ((*tmp).size()!=0){
858                                cout << "elements: ";
859                                for (int j = 0; j < (*tmp).size();j++){
860                                        cout << (int)(*tmp)[j] << " ";
861                                }
862                                cout << endl;
863                        }
864                        cout << endl;
865                }
866        }
867*/
868}
869/*
870static inline int NameStrt_check(int pos) {
871        int block_pos = block_base + pos;
872        if(XML_10_UTF8_NameStrt_bytes((unsigned char*)&source[block_pos]) == 0){
873              ReportError("name start error", pos);
874              exit(-1);
875        }
876        return 0;
877}
878
879static inline int Name_check(int pos) {
880        int block_pos = block_base + pos;
881        if(XML_10_UTF8_NameChar_bytes((unsigned char*)&source[block_pos]) == 0){
882              ReportError("name error", pos);
883              exit(-1);
884        }
885        return 0;
886}
887
888static inline int PIName_check(int pos) {
889        int block_pos = block_base + pos;
890        int file_pos = block_pos+buffer_base;
891        printf ("%s:%i\n",__FUNCTION__,pos);
892        if (at_XxMmLll<ASCII>((unsigned char*)&source[block_pos]) && (source[block_pos+3]=='?' || source[block_pos+3]<= ' ')) {
893              // "<?xml" legal at start of file.
894              if ((file_pos == 2) && at_XmlDecl_start<ASCII>((unsigned char*)&source[0])) return 0;
895              ReportError("[Xx][Mm][Ll] illegal as PI name", pos);
896              exit(-1);
897        }
898        return 0;
899}
900
901static inline int CD_check(int pos) {
902        int block_pos = block_base + pos;
903        if (!at_CDATA1<ASCII>((unsigned char*)&source[block_pos])){
904              ReportError("CDATA error", pos);
905              exit(-1);
906        }
907        return 0;
908}
909
910static inline int GenRef_check(int pos) {
911        int block_pos = block_base + pos;
912        unsigned char* s = (unsigned char*)&source[block_pos];
913        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))){
914                        cout << pos << endl;
915              ReportError("Undefined reference", pos);
916              exit(-1);
917        }
918        return 0;
919}
920
921static inline int HexRef_check(int pos) {
922        int block_pos = block_base + pos;
923        unsigned char* s = (unsigned char*)&source[block_pos];
924        int ch_val = 0;
925        while(at_HexDigit<ASCII>(s)){
926          ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
927          if (ch_val> 0x10FFFF ){
928            ReportError("Illegal character reference", pos);
929            exit(-1);
930          }
931          s++;
932        }
933        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
934          ReportError("Illegal character reference", pos);
935          exit(-1);
936        }
937        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
938          ReportError("Illegal XML 1.0 character reference", pos);
939          exit(-1);
940        }
941        return 0;
942}
943
944static inline int DecRef_check(int pos) {
945        int block_pos = block_base + pos;
946        unsigned char* s = (unsigned char*)&source[block_pos];
947        int ch_val = 0;
948        while(at_HexDigit<ASCII>(s)){
949          ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
950          if (ch_val> 0x10FFFF ){
951            ReportError("Illegal character reference", pos);
952            exit(-1);
953          }
954          s++;
955        }
956        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
957          ReportError("Illegal character reference", pos);
958          exit(-1);
959        }
960        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
961          ReportError("Illegal XML 1.0 character reference", pos);
962          exit(-1);
963        }
964        return 0;
965}
966
967static inline int AttRef_check(int pos) {
968        int block_pos = block_base + pos;
969        unsigned char* s = (unsigned char*)&source[block_pos];
970        int ch_val = 0;
971        if(s[0]=='#'){
972          s++;
973          if(s[0]=='x' || s[0]=='X'){
974            s++;
975            while(at_HexDigit<ASCII>(s)){
976              ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
977              s++;
978            }
979          }
980          else{
981            while(at_HexDigit<ASCII>(s)){
982              ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
983              s++;
984            }
985          }
986          if (ch_val==60){
987            ReportError("Attribute values contain '<' characters after reference expansion", pos);
988            exit(-1);
989          }
990        }
991        else if(at_Ref_lt<ASCII>(s)){
992          ReportError("Attribute values contain '<' characters after reference expansion", pos);
993          exit(-1);
994        }
995        return 0;
996}
997*/
998
999
1000
1001
1002/*
1003static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
1004  s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
1005        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);
1006}
1007
1008static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask) {
1009  s2p_do_block(U8, basis_bits);
1010  basis_bits.bit_0 = simd_and(basis_bits.bit_0, EOF_mask);
1011  basis_bits.bit_1 = simd_and(basis_bits.bit_1, EOF_mask);
1012  basis_bits.bit_2 = simd_and(basis_bits.bit_2, EOF_mask);
1013  basis_bits.bit_3 = simd_and(basis_bits.bit_3, EOF_mask);
1014  basis_bits.bit_4 = simd_and(basis_bits.bit_4, EOF_mask);
1015  basis_bits.bit_5 = simd_and(basis_bits.bit_5, EOF_mask);
1016  basis_bits.bit_6 = simd_and(basis_bits.bit_6, EOF_mask);
1017  basis_bits.bit_7 = simd_and(basis_bits.bit_7, EOF_mask);
1018}
1019*/
1020
1021static inline void print_elem_vec(vector<char>* vec, int size, int depth){
1022        cout << "vector " << depth << ":";
1023        for (int i = 0; i<size ; i++){
1024                cout << (int)(*vec)[i] <<" ";
1025        }
1026        cout << endl;
1027}
1028
1029static inline void vec_scan(BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> match_scanner,BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> f_vec_scanner,char* str,int index){
1030        int current_pos = 0;
1031        int next_pos = 0;
1032        int match_pos = 0;
1033//      cout << str <<" = " << index <<endl;
1034//      cout << "vec_scan" << endl;
1035        cout << f_vec_scanner.get_final_pos() << "&&" << endl;
1036        if(f_vec_scanner.has_next()){
1037                current_pos = f_vec_scanner.scan_to_next();
1038//              cout << current_pos << endl;
1039        }else{
1040                return;
1041        }
1042        if (match_scanner.has_next()){
1043                match_pos = match_scanner.scan_to_next();
1044        }else{
1045                printf("Mismatch found at pos of %s %d: %d.\n",str,index,current_pos);
1046                while(f_vec_scanner.has_next()){
1047                        current_pos = f_vec_scanner.scan_to_next();
1048                        printf("Mismatch found at pos of %s %d: %d.\n",str,index,current_pos);
1049                }
1050                return;
1051        }
1052        while(1){
1053                if(f_vec_scanner.has_next()){
1054                        next_pos = f_vec_scanner.scan_to_next();
1055                }else{
1056                        next_pos = -1;
1057                }
1058                if(next_pos > match_pos){
1059                        cout <<"##" << next_pos << "  " << match_pos << endl; 
1060                        current_pos = next_pos;
1061                        match_pos = match_scanner.scan_to_next();
1062                        continue;
1063                }else if(next_pos == -1){
1064                        break;
1065                }else if(next_pos < match_pos){
1066                        cout << next_pos << "  " << match_pos << endl; 
1067                        printf("Mismatch found at pos of %s %d: %d.\n",str,index,current_pos);
1068                        current_pos = next_pos;
1069                }
1070        }
1071/*     
1072        while(1){
1073                if(f_vec_scanner.has_next()){
1074                        next_pos = f_vec_scanner.scan_to_next();
1075                }else{
1076                        next_pos = -1;
1077                }
1078                if (match_pos > next_pos && next_pos != -1){
1079                        printf("Mismatch found at pos of %s %d: %d.\n",str,index,current_pos);
1080                }else if (next_pos == -1){
1081                        break;
1082                }else{
1083                        if(match_scanner.has_next()){
1084                                match_pos = match_scanner.scan_to_next();
1085                        }else{
1086                                printf("Mismatch found at pos of %s %d: %d.\n",str,index,next_pos);
1087                                while(f_vec_scanner.has_next()){
1088                                        current_pos = f_vec_scanner.scan_to_next();
1089                                        printf("Mismatch found at pos of %s %d: %d.\n",str,index,current_pos);
1090                                }
1091                                return;
1092                        }
1093                }
1094                current_pos = next_pos;
1095        }
1096*/
1097}
1098
1099static inline void validate_mul_block(){
1100        struct Elem elem;
1101        Validation_2 validation_2;
1102        Validation_4 validation_4;
1103        Validation_9 validation_9;
1104//      Validation_10 validation_10;
1105       
1106        struct Lex lex;
1107       
1108        struct Output output;
1109
1110        Classify_bytes classify_bytes;
1111        int j;
1112#ifdef DEBUG
1113        for(j=0;j<MAX_COUNT;j++){
1114        int lgth = gid_vec[j].size();
1115                if(!gid_vec[j].empty())
1116                        print_elem_vec(&(gid_vec[j]),lgth,j);
1117        }
1118#endif
1119        for(j=0;j<MAX_COUNT;j++){
1120                cout << gid_vec[j].size() << endl;
1121        }
1122        int lgth;
1123        for(j=0;j<MAX_COUNT;j++){
1124                lgth = gid_vec[j].size();
1125                int remaining = 0;
1126                Basis_bits temp_basis_bits;
1127                const int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
1128                int i = 0;
1129                int block_base;
1130                if(lgth != 0){ 
1131                        remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
1132                        for(i = 0;i < num_block; i++){
1133                                block_base = i*BLOCK_SIZE;
1134                               
1135                                s2p_do_block((BytePack*)(&(gid_vec[j][block_base])), temp_basis_bits);
1136                                classify_bytes.do_block(temp_basis_bits,lex);
1137                                switch (j){
1138                                        case 2:
1139                                        validation_2.do_block(lex,output);
1140#ifdef DEBUG                           
1141                                        print_register("cc2",lex.cc2);
1142                                        print_register("match_2",output.matches);
1143#endif
1144                                        break;
1145                                        case 4:
1146                                        validation_4.do_block(lex,output);
1147#ifdef DEBUG
1148                                        print_register("cc4",lex.cc4);
1149                                        print_register("match_4",output.matches);
1150#endif
1151                                        break;
1152                                        case 9:
1153                                        validation_9.do_block(lex,output);
1154#ifdef DEBUG
1155                                        print_register("cc9",lex.cc9);
1156                                        print_register("match_9",output.matches);
1157#endif
1158                                        break;
1159/*
1160                                        case 10:
1161                                        validation_10.do_block(lex,output);
1162#ifdef DEBUG
1163                                        print_register("cc10",lex.cc10);
1164                                        print_register("match_10",output.matches);
1165#endif
1166                                        break;
1167*/
1168                                }
1169                        }
1170                        if (remaining !=0){
1171                                block_base = i*BLOCK_SIZE;
1172                                //cout << "block_base " << block_base << endl;
1173                                BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
1174                                s2p_do_final_block((BytePack*)(&(gid_vec[j][block_base])), temp_basis_bits,EOF_mask);
1175                                classify_bytes.do_final_block(temp_basis_bits,lex,EOF_mask);
1176                                switch (j){
1177                                        case 2:
1178                                        validation_2.do_final_block(lex,output,EOF_mask);
1179#ifdef DEBUG
1180//                                      cout << remaining << endl;
1181                                        print_register("cc2",lex.cc2);
1182//                                      print_register("cc3",lex.cc3);
1183//                                      print_register("cc4",lex.cc4);
1184//                                      print_register("cc9",lex.cc9);
1185                                        print_register("match_2",output.matches);
1186#endif
1187                                        break;
1188                                        case 4:
1189                                        validation_4.do_final_block(lex,output,EOF_mask);
1190#ifdef DEBUG
1191                                        print_register("cc4",lex.cc4);
1192                                        print_register("match_4",output.matches);
1193#endif
1194                                        break;
1195                                        case 9:
1196                                        validation_9.do_final_block(lex,output,EOF_mask);
1197#ifdef DEBUG
1198                                        print_register("cc9",lex.cc9);
1199                                        print_register("match_9",output.matches);
1200#endif
1201                                        break;
1202/*
1203                                        case 10:
1204                                        validation_10.do_final_block(lex,output,EOF_mask);
1205#ifdef DEBUG
1206                                        print_register("cc10",lex.cc10);
1207                                        print_register("match_10",output.matches);
1208#endif
1209                                        break;
1210*/
1211                                }
1212                        }
1213                }
1214        }
1215}
1216
1217
1218
1219/*
1220
1221static inline void validate_mul_block(){
1222        struct Elem elem;
1223        Validation_2 validation_2;
1224//      Validation_2 validation_2;
1225        Validation_4 validation_4;
1226        Validation_9 validation_9;
1227//      Validation_4 validation_4;     
1228//      Validation_5 validation_5;
1229//      Validation_24 validation_24;
1230//      Validation_25 validation_25;
1231//      Validation_27 validation_27;
1232//      Validation_35 validation_35;
1233//      Validation_41 validation_41;
1234//      Validation_45 validation_45;
1235       
1236        struct Lex lex;
1237       
1238        struct Output output;
1239
1240        Classify_bytes classify_bytes;
1241        int j;
1242#ifdef DEBUG
1243        for(j=0;j<MAX_COUNT;j++){
1244        int lgth = gid_vec[j].size();
1245                if(!gid_vec[j].empty())
1246                        print_elem_vec(&(gid_vec[j]),lgth,j);
1247        }
1248#endif
1249        BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> match_scanner;
1250        BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> f_vec_scanner;
1251        match_scanner.init();
1252        f_vec_scanner.init();
1253        int lgth;
1254        for(j=0;j<MAX_COUNT;j++){
1255                lgth = gid_vec[j].size();
1256                int remaining = 0;
1257                Basis_bits temp_basis_bits;
1258                const int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
1259                int i = 0;
1260                int block_base;
1261               
1262                if(lgth != 0){ 
1263                        remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
1264                        for(i = 0;i < num_block; i++){
1265                                block_base = i*BLOCK_SIZE;
1266                                //cout << "block_base " << block_base << endl;
1267                       
1268                                s2p_do_block((BytePack*)(&(gid_vec[j][block_base])), temp_basis_bits);
1269                                //print_elem_vec(&((vector*)(gid_vec[j][block_base])),BLOCK_SIZE,j);
1270                                //print_basis_bits(temp_basis_bits);
1271
1272                                classify_bytes.do_block(temp_basis_bits,lex);
1273                                switch (j){
1274                                        case 2:
1275                                        validation_2.do_block(lex,output);
1276                                        f_vec_scanner.load_block(lex.cc2,i);
1277#ifdef DEBUG                           
1278                                        print_register("cc2",lex.cc2);
1279                                        print_register("match_2",output.matches);
1280#endif
1281                                        break;
1282                                        case 4:
1283                                        validation_4.do_block(lex,output);
1284                                        f_vec_scanner.load_block(lex.cc4,i);
1285#ifdef DEBUG
1286                                        print_register("cc4",lex.cc4);
1287                                        print_register("match_4",output.matches);
1288#endif
1289                                        break;
1290                                        case 9:
1291                                        validation_9.do_block(lex,output);
1292                                        f_vec_scanner.load_block(lex.cc9,i);
1293#ifdef DEBUG
1294                                        print_register("cc9",lex.cc9);
1295                                        print_register("match_9",output.matches);
1296#endif
1297                                        break;
1298                                }
1299
1300                                match_scanner.load_block(output.matches,i);
1301
1302                        }
1303                        if (remaining !=0){
1304                                block_base = i*BLOCK_SIZE;
1305                                //cout << "block_base " << block_base << endl;
1306                                BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
1307                                s2p_do_final_block((BytePack*)(&(gid_vec[j][block_base])), temp_basis_bits,EOF_mask);
1308                                //print_elem_vec(&((vector*)(gid_vec[j][block_base])),BLOCK_SIZE,j);
1309                                //print_basis_bits(temp_basis_bits);
1310                                //print_elem_vec((vector<char>*)(gid_vec[j][block_base]),remaining,j);
1311                       
1312                                classify_bytes.do_final_block(temp_basis_bits,lex,EOF_mask);
1313                                switch (j){
1314                                        case 2:
1315                                        validation_2.do_final_block(lex,output,EOF_mask);
1316                                        f_vec_scanner.load_block(lex.cc2,i);
1317#ifdef DEBUG
1318//                                      cout << remaining << endl;
1319                                        print_register("cc2",lex.cc2);
1320//                                      print_register("cc3",lex.cc3);
1321//                                      print_register("cc4",lex.cc4);
1322//                                      print_register("cc9",lex.cc9);
1323                                        print_register("match_2",output.matches);
1324#endif
1325                                        break;
1326                                        case 4:
1327                                        validation_4.do_final_block(lex,output,EOF_mask);
1328                                        f_vec_scanner.load_block(lex.cc4,i);
1329#ifdef DEBUG
1330                                        print_register("cc4",lex.cc4);
1331                                        print_register("match_4",output.matches);
1332#endif
1333                                        break;
1334                                        case 9:
1335                                        validation_9.do_final_block(lex,output,EOF_mask);
1336                                        f_vec_scanner.load_block(lex.cc9,i);
1337#ifdef DEBUG
1338                                        print_register("cc9",lex.cc9);
1339                                        print_register("match_9",output.matches);
1340#endif
1341                                        break;
1342                                }
1343                               
1344                                match_scanner.load_block(output.matches,i);
1345                        }
1346                }
1347        }
1348        if(lgth != 0){
1349                        vec_scan(match_scanner,f_vec_scanner,"Element",j);     
1350        }
1351       
1352
1353}
1354
1355
1356*/
1357
1358/*
1359static inline void validate(){
1360        struct Elem elem;
1361        Validation_1 validation_1;
1362        struct Lex lex;
1363        struct Output output;
1364        Classify_bytes classify_bytes;
1365        cout << "vector size " << gid_vec.size() << endl;
1366        int lgth = gid_vec.size();
1367        int remaining = 0;
1368        int current_pos = 0;
1369        Basis_bits temp_basis_bits;
1370
1371        ForwardScanner<BitBlock, ScanWord> match_scanner;
1372        ReverseScanner<BitBlock, ScanWord> vec_scanner;
1373        ForwardScanner<BitBlock, ScanWord> f_vec_scanner;
1374        int block_base = 0;
1375        if (lgth != 0){
1376                int i = 0;
1377                int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
1378                remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
1379                for (i = 0;i < num_block; i++){
1380//                      s2p_do_block((BytePack*)(vector_11[i]),temp_basis_bits);
1381                        s2p_do_block((BytePack*)(&(gid_vec[i])), temp_basis_bits);
1382                        print_elem_vec(&(gid_vec),lgth);
1383                        print_basis_bits(temp_basis_bits);
1384                       
1385                        classify_bytes.do_block(temp_basis_bits,lex);
1386                        validation_1.do_block(lex,output);
1387                       
1388                        match_scanner.init(&output.matches);
1389                        vec_scanner.init(&lex.cc1);
1390                        match_scanner.scan_to_next();
1391                        f_vec_scanner.init(&lex.cc1);
1392                        match_scanner.scan_to_next();
1393                        f_vec_scanner.scan_to_next();
1394                        current_pos = f_vec_scanner.get_pos();
1395                        vec_scanner.move_to(match_scanner.get_pos());
1396                        vec_scanner.scan_to_next();
1397//                      cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
1398                        if (vec_scanner.get_pos() != current_pos){
1399                                printf("#Mismatch found at pos: %d.\n",current_pos+block_base);
1400                        }
1401//                      out = simd_or(out,lex.cc1);
1402//                      print_register("out",out);
1403                       
1404                        while(!(match_scanner.is_done() || f_vec_scanner.is_done())){
1405                                f_vec_scanner.scan_to_next();
1406                                while(!(match_scanner.is_done())){
1407                                        match_scanner.scan_to_next();
1408                                        if(match_scanner.get_pos()>0){
1409                                                vec_scanner.move_to(match_scanner.get_pos());
1410                                                vec_scanner.scan_to_next();
1411                                        }
1412                                        if (vec_scanner.get_pos() != current_pos){
1413                                                        break;
1414                                        }
1415                                }
1416                                cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
1417                                if (f_vec_scanner.get_pos()>0){
1418                                        current_pos = f_vec_scanner.get_pos();
1419                                }
1420                                if (vec_scanner.get_pos() != current_pos){
1421                                        printf("Mismatch found at pos: %d.\n",current_pos+block_base);
1422                                }
1423//                              out = simd_or(out,lex.cc1);
1424//                              cout << "match_scanner_pos = " << match_scanner.get_pos() << endl;
1425//                              cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
1426//                              if(match_scanner.get_pos() == vec_scanner.get_pos()){
1427//                                      printf("Match found of element with id of '1'\n");                             
1428//                              }
1429                        }
1430                               
1431                       
1432//                      (BytePack*)(iter->second)
1433//                      validate_Elem_Vec.do_block(elem, temp_basis_bits);
1434                        cout << i ;
1435                        block_base += BLOCK_SIZE;
1436                }
1437                if (remaining !=0){
1438                        BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
1439                        s2p_do_final_block((BytePack*)(&(gid_vec[i])), temp_basis_bits,EOF_mask);
1440                        print_elem_vec(&(gid_vec),lgth);
1441                        print_basis_bits(temp_basis_bits);
1442                       
1443                        classify_bytes.do_block(temp_basis_bits,lex);
1444                        validation_1.do_block(lex,output);
1445                        print_register("output.matches",output.matches);
1446                        print_register("lex.cc1",lex.cc1);
1447                        match_scanner.init(&output.matches);
1448                        vec_scanner.init(&lex.cc1);
1449                        f_vec_scanner.init(&lex.cc1);
1450                        match_scanner.scan_to_next();
1451                        f_vec_scanner.scan_to_next();
1452                        current_pos = f_vec_scanner.get_pos();
1453                        cout << "current_pos = " << current_pos << endl;
1454//                      cout << "match_scanner_pos = " << match_scanner.get_pos()<< endl;
1455//                      cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
1456                        vec_scanner.move_to(match_scanner.get_pos());
1457                        vec_scanner.scan_to_next();
1458                        cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
1459                        if (vec_scanner.get_pos() != current_pos){
1460                                printf("#Mismatch found at pos: %d.\n",current_pos+block_base);
1461                        }
1462//                      out = simd_or(out,lex.cc1);
1463//                      print_register("out",out);
1464                       
1465                        while(!(match_scanner.is_done() || f_vec_scanner.is_done())){
1466                                f_vec_scanner.scan_to_next();
1467                                while(!(match_scanner.is_done())){
1468                                        match_scanner.scan_to_next();
1469                                        if(match_scanner.get_pos()>0){
1470                                                vec_scanner.move_to(match_scanner.get_pos());
1471                                                vec_scanner.scan_to_next();
1472                                        }
1473                                        if (vec_scanner.get_pos() != current_pos){
1474                                                        break;
1475                                        }
1476                                }
1477                                cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
1478                                if (f_vec_scanner.get_pos()>0){
1479                                        current_pos = f_vec_scanner.get_pos();
1480                                }
1481                                if (vec_scanner.get_pos() != current_pos){
1482                                        printf("Mismatch found at pos: %d.\n",current_pos+block_base);
1483                                }
1484//                              out = simd_or(out,lex.cc1);
1485//                              cout << "match_scanner_pos = " << match_scanner.get_pos() << endl;
1486//                              cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
1487//                              if(match_scanner.get_pos() == vec_scanner.get_pos()){
1488//                                      printf("Match found of element with id of '1'\n");                             
1489//                              }
1490                        }
1491//                      validate_Elem_Vec.do_final_block(elem, temp_basis_bits, EOF_mask);
1492                }
1493        }
1494/*
1495        vector<int> test;
1496        for(int i = 1;i <12; i++){
1497                test.push_back(i);
1498        }
1499//      int test[] = {1,2,3,4,5,6,7,8,9,10,11};
1500        Basis_bits temp_basis_bits;
1501        BitBlock EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-44));
1502        s2p_do_final_block((BytePack*)(&(test[0])), temp_basis_bits,EOF_mask);
1503        print_basis_bits(temp_basis_bits);
1504*/
1505/*
1506        for (map<char, vector<char>* > ::const_iterator iter = elem_vec_map.begin(); iter!= elem_vec_map.end(); ++iter){
1507                int i = 0;
1508                int lgth = (*(iter->second)).size();
1509                int remaining;
1510                if (lgth != 0){
1511                        cout <<"vector key "<< (int)iter->first << endl;
1512//                      cout <<"vector ptr" << iter->second<<endl;
1513               
1514                        cout <<"vector size: " << lgth << endl;
1515                        int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
1516                        remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
1517                        for (i = 0;i < num_block; i++){
1518                                Basis_bits temp_basis_bits;
1519                                s2p_do_block(((BytePack*)(&(*(iter->second))[i])), temp_basis_bits);
1520                                print_elem_vec(iter->second,lgth);
1521                                print_basis_bits(temp_basis_bits);
1522//                              (BytePack*)(iter->second)
1523                                cout << i ;
1524                        }
1525                        cout << endl;
1526                        if (remaining !=0){
1527                                BitBlock EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-remaining));
1528                                Basis_bits temp_basis_bits;
1529                                s2p_do_final_block(((BytePack*)(&(*(iter->second))[i])), temp_basis_bits,EOF_mask);
1530                                print_elem_vec((iter->second)+i,lgth);
1531                                print_basis_bits(temp_basis_bits);
1532                        }
1533                }                       
1534        }
1535*/
1536/*
1537}
1538*/
1539
1540static inline void vectoring(Tag_Callouts & tag_Callouts, Hash_data & hash_data,char *source,int block_base){
1541
1542        elem_starts = tag_Callouts.ElemName_starts;
1543    hashvalues[1] = hash_data.Hash_value;
1544   
1545//    pre_index.push(0);
1546   
1547        StreamScanLengthGrouping(source,block_base,(ScanBlock *) &tag_Callouts.ElemName_ends,(ScanBlock *) &tag_Callouts.Tag_closing, sizeof(BitBlock)/sizeof(ScanBlock),(ScanBlock *) &tag_Callouts.Content_starts,(ScanBlock *) &tag_Callouts.EndTag_marks);
1548       
1549        // Store the last starting position in case we hit boundary case
1550    previous_block_last_elem_start = - count_reverse_zeroes(elem_starts);
1551
1552    //copy current hash value data as previous one.
1553    memmove (&hashvalues[0], &hashvalues[1], 16);
1554}
1555/*
1556static 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){
1557
1558
1559    //NOTE: We are NOT handling the case for an extremely long symbol name (length > 1541).
1560    //      TagMatcher will crash if we feed a long symbol name.
1561    //      Sample file: test/long_sym_name.xml
1562
1563    tracker.StoreNewlines(lex.LF);
1564    elem_starts = tag_Callouts.ElemName_starts;
1565    hashvalues[1] = hash_data.Hash_value;
1566
1567        StreamScanLengthGrouping((ScanBlock *) &tag_Callouts.ElemName_ends,(ScanBlock *) &tag_Callouts.Tag_closing, sizeof(BitBlock)/sizeof(ScanBlock));
1568       
1569/*
1570    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_1) )
1571    {
1572        StreamScanLengthGrouping<1>((ScanBlock *) &tag_Callouts.ElemName_ends_1,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1573    }
1574
1575    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_2) )
1576    {
1577        StreamScanLengthGrouping<2>((ScanBlock *) &tag_Callouts.ElemName_ends_2,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1578    }
1579
1580    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_3) )
1581    {
1582        StreamScanLengthGrouping<3>((ScanBlock *) &tag_Callouts.ElemName_ends_3,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1583    }
1584
1585    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_4) )
1586    {
1587        StreamScanLengthGrouping<4>((ScanBlock *) &tag_Callouts.ElemName_ends_4,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1588    }
1589
1590    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_5) )
1591    {
1592        StreamScanLengthGrouping<5>((ScanBlock *) &tag_Callouts.ElemName_ends_5,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1593    }
1594
1595    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_6) )
1596    {
1597        StreamScanLengthGrouping<6>((ScanBlock *) &tag_Callouts.ElemName_ends_6,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1598    }
1599
1600    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_7) )
1601    {
1602        StreamScanLengthGrouping<7>((ScanBlock *) &tag_Callouts.ElemName_ends_7,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1603    }
1604
1605    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_8) )
1606    {
1607        StreamScanLengthGrouping<8>((ScanBlock *) &tag_Callouts.ElemName_ends_8,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1608    }
1609
1610    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_9) )
1611    {
1612        StreamScanLengthGrouping<9>((ScanBlock *) &tag_Callouts.ElemName_ends_9,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1613    }
1614
1615    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_10) )
1616    {
1617        StreamScanLengthGrouping<10>((ScanBlock *) &tag_Callouts.ElemName_ends_10,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1618    }
1619
1620    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_11) )
1621    {
1622        StreamScanLengthGrouping<11>((ScanBlock *) &tag_Callouts.ElemName_ends_11,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1623    }
1624
1625    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_12) )
1626    {
1627        StreamScanLengthGrouping<12>((ScanBlock *) &tag_Callouts.ElemName_ends_12,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1628    }
1629
1630    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_13) )
1631    {
1632        StreamScanLengthGrouping<13>((ScanBlock *) &tag_Callouts.ElemName_ends_13,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1633    }
1634
1635    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_14) )
1636    {
1637        StreamScanLengthGrouping<14>((ScanBlock *) &tag_Callouts.ElemName_ends_14,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1638    }
1639
1640    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_15) )
1641    {
1642        StreamScanLengthGrouping<15>((ScanBlock *) &tag_Callouts.ElemName_ends_15,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1643    }
1644
1645    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_16) )
1646    {
1647        StreamScanLengthGrouping<16>((ScanBlock *) &tag_Callouts.ElemName_ends_16,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1648    }
1649
1650    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_17_and_longer) )
1651    {
1652        StreamScanLengthGrouping<17>((ScanBlock *) &tag_Callouts.ElemName_ends_17_and_longer,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1653    }
1654
1655*/
1656
1657
1658/*
1659    // Store the last starting position in case we hit boundary case
1660    previous_block_last_elem_start = - count_reverse_zeroes(elem_starts);
1661
1662    //copy current hash value data as previous one.
1663    memmove (&hashvalues[0], &hashvalues[1], 16);
1664
1665    if (bitblock::any(simd_or(check_streams.non_ascii_name_starts, check_streams.non_ascii_names))) {
1666      StreamScan((ScanBlock *) &check_streams.non_ascii_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), NameStrt_check);
1667      StreamScan((ScanBlock *) &check_streams.non_ascii_names, sizeof(BitBlock)/sizeof(ScanBlock), Name_check);
1668    }
1669
1670    if (bitblock::any(ctCDPI_Callouts.PI_name_starts)){
1671      StreamScan((ScanBlock *) &ctCDPI_Callouts.PI_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), PIName_check);
1672    }
1673
1674    if (bitblock::any(ctCDPI_Callouts.CD_starts)){
1675      StreamScan((ScanBlock *) &ctCDPI_Callouts.CD_starts, sizeof(BitBlock)/sizeof(ScanBlock), CD_check);
1676    }
1677
1678    if (bitblock::any(ref_Callouts.GenRef_starts)){
1679      StreamScan((ScanBlock *) &ref_Callouts.GenRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), GenRef_check);
1680    }
1681
1682    if (bitblock::any(ref_Callouts.DecRef_starts)){
1683      StreamScan((ScanBlock *) &ref_Callouts.DecRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), DecRef_check);
1684    }
1685
1686    if (bitblock::any(ref_Callouts.HexRef_starts)){
1687      StreamScan((ScanBlock *) &ref_Callouts.HexRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), HexRef_check);
1688    }
1689
1690    if (bitblock::any(check_streams.att_refs)){
1691      StreamScan((ScanBlock *) &check_streams.att_refs, sizeof(BitBlock)/sizeof(ScanBlock), AttRef_check);
1692    }
1693
1694//    error_tracker.If_Error_Report_First();
1695/*
1696    matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
1697    tracker.AdvanceBlock();
1698    */
1699    /*
1700}
1701*/
1702
1703static inline void print_GIDS()
1704{
1705    int span_count = gids.size();
1706    for(int i=0;i<span_count;i++) {
1707             cout << gids[i] << " ";
1708    }
1709    cout << endl;
1710}
1711
1712static inline int test(int)
1713{
1714    return 0;
1715}
1716
1717void do_process(FILE *infile, FILE *outfile) {
1718
1719        ///////////////
1720        //gid file
1721        ///////////////
1722        gid_writein = fopen("gid.out","w");
1723@decl
1724        #ifndef STL_ALIGNED_VECTOR
1725                TagMatcher<SEGMENT_SIZE,LOOKAHEAD_SIZE> matcher;
1726        #endif
1727        ///////////////////////////////////////////////////
1728        //preload element_IDs into symbol table from schema
1729        ///////////////////////////////////////////////////
1730        FILE *element_ID_in = fopen("../test/element_ID","r");
1731        char symbol[50];
1732        int index;
1733        if(element_ID_in == NULL){
1734                printf("Error opening element_ID file.\n");
1735                exit(0);
1736        }
1737        hashvalues[1] = hash_data.Hash_value;
1738        while(fscanf(element_ID_in,"%s %d\n",&symbol[0],&index)==2){
1739                int lgth = strlen(symbol);
1740                int hashvalue = compute_hash_value2(symbol,lgth);
1741//              cout << symbol <<" "<< lgth<<" "<<hashvalue << endl;
1742                int gid = 0;
1743                switch (lgth)
1744        {
1745                        case 1:
1746                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<1>(symbol, hashvalue);
1747                        break;
1748                        case 2:
1749                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<2>(symbol, hashvalue);
1750                        break;
1751                        case 3:
1752                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<3>(symbol, hashvalue);
1753                        break;
1754                        case 4:
1755                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<4>(symbol, hashvalue);
1756                        break;
1757                        case 5:
1758                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<5>(symbol, hashvalue);
1759                        break;
1760                        case 6:
1761                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<6>(symbol, hashvalue);
1762                        break;
1763                        case 7:
1764                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<7>(symbol, hashvalue);
1765                        break;
1766                        case 8:
1767                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<8>(symbol, hashvalue);
1768                        break;
1769                        case 9:
1770                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<9>(symbol, hashvalue);
1771                        break;
1772                        case 10:
1773                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<10>(symbol, hashvalue);
1774                        break;
1775                        case 11:
1776                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<11>(symbol, hashvalue);
1777                        break;
1778                        case 12:
1779                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<12>(symbol, hashvalue);
1780                        break;
1781                        case 13:
1782                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<13>(symbol, hashvalue);
1783                        break;
1784                        case 14:
1785                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<14>(symbol, hashvalue);
1786                        break;
1787                        case 15:
1788                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<15>(symbol, hashvalue);
1789                        break;
1790                        case 16:
1791                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<16>(symbol, hashvalue);
1792                        break;
1793                        default:
1794                        gid = pbgs_symbol_table.Lookup_or_Insert_Name(symbol, hashvalue, lgth);
1795                        break;         
1796                }
1797#ifdef DEBUG
1798                fprintf (gid_writein,"%s |  lgth: %i | hashvalue: %i | gid: %i | symbol: %s\n", __FUNCTION__,  lgth, hashvalue, gid, symbol);
1799#endif
1800        }       
1801        fclose(element_ID_in);
1802//      return;
1803
1804        int buffer_base = 0;
1805        int block_base = 0;
1806        int buffer_pos = 0;
1807        int block_pos = 0;
1808        int errpos = 0;
1809        int chars_avail = 0;
1810        int check_pos = 0;
1811        int chars_read = 0;
1812 
1813        //////////////////////////////////////////////////////////////////////////////////////////
1814    // Buffer Management
1815    //////////////////////////////////////////////////////////////////////////////////////////
1816                //      BitBlock buf[(BUFFER_SIZE)/sizeof(BitBlock)];
1817                //      uint8_t * src_buffer = (uint8_t *)buf + COPYBACK_SIZE;
1818
1819                #ifdef STL_ALIGNED_VECTOR
1820                        std::vector<uint8_t, AAllocator<uint8_t> > src_buffer;
1821                        src_buffer.reserve(BUFFER_SIZE);
1822                #else
1823                        char * COPYBACK;
1824                        char * src_buffer;
1825                        ALLOC_STATIC_ALIGNED_BYTE_BUFFER_WITH_COPYBACK(COPYBACK, src_buffer);
1826                #endif
1827  /*
1828  BytePack buf[(BUFFER_SIZE+BLOCK_SIZE+LOOKAHEAD_SIZE*2)/sizeof(SIMD_type)];
1829
1830  char * srcbuf = ((char *) buf) + LOOKAHEAD_SIZE;
1831  buffer_base = buf_pos;
1832  source = srcbuf;
1833  */
1834  chars_read = fread((void *)&src_buffer[0], 1, SEGMENT_SIZE, infile);
1835  chars_avail = chars_read;
1836  if (chars_avail > BUFFER_SIZE) chars_avail = SEGMENT_SIZE;
1837
1838  if(chars_read<4){
1839    fprintf(stderr,"File is too short. Not well formed.\n");
1840    exit(-1);
1841  }
1842
1843  Entity_Info * e = new Entity_Info;
1844  e->AnalyzeSignature((unsigned char *)&src_buffer[0]);
1845
1846  if (e->code_unit_base == ASCII) {
1847
1848    XML_Decl_Parser<ASCII> decl_parser((unsigned char *)&src_buffer[0]);
1849
1850    decl_parser.ReadXMLInfo(*e);
1851
1852    if (e->code_unit_size != SingleByte || (e->has_encoding_decl && (!at_UTF_8(e->encoding)))){
1853        fprintf(stderr,"Sorry, this xmlwf demo only works for UTF-8.\n");
1854        exit(-1);
1855    }
1856  }
1857  else {
1858    fprintf(stderr,"Sorry, this xmlwf demo does not process EBCDIC.\n");
1859        exit(-1);
1860  }
1861
1862  if (e->content_start != 0) {
1863        memmove(&src_buffer[0], &src_buffer[e->content_start], chars_read - e->content_start);
1864        buffer_pos = e->content_start;
1865//      buffer_base = buffer_pos;
1866        if ((chars_avail-e->content_start) < SEGMENT_SIZE) {
1867                        chars_read = chars_avail - e->content_start + fread(&src_buffer[chars_avail-e->content_start], 1, e->content_start, infile);
1868                        chars_avail = chars_read;
1869                }
1870                if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
1871  }
1872
1873        //////////////////////////////////////////////////////////////////////////////////////////
1874        // Read OVERLAP bytes to support post processing validation lookahead.
1875        //////////////////////////////////////////////////////////////////////////////////////////
1876        chars_read = chars_avail + fread(&src_buffer[chars_avail], 1, LOOKAHEAD_SIZE, infile);
1877        chars_avail = chars_read;
1878        if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
1879
1880@stream_stmts
1881
1882        #ifndef STL_ALIGNED_VECTOR
1883        matcher.setSrc((char *)&src_buffer[0]);
1884        #endif
1885
1886/* Full Buffers */
1887    int block_segment_num = 0;
1888    while (chars_avail >= SEGMENT_SIZE) {
1889      PERF_SEC_START(parser_timer);
1890      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
1891//              cout << "loops" << ends;
1892                block_base = blk*BLOCK_SIZE;
1893        s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
1894     
1895                @block_stmts
1896         
1897                tracker.StoreNewlines(lex.LF);
1898//              cout << "post start" << endl;
1899//              postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
1900                postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
1901                vectoring(tag_Callouts,hash_data,(char *)&src_buffer[0],block_base);
1902//              cout << "post done" << endl;
1903                #ifndef STL_ALIGNED_VECTOR
1904                matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
1905                #endif
1906                tracker.AdvanceBlock();
1907//              cout << "loop" << endl;
1908      }
1909      #ifndef STL_ALIGNED_VECTOR
1910      matcher.StreamScan(chars_avail);
1911      matcher.Advance_buffer();
1912      #endif
1913      PERF_SEC_END(parser_timer, chars_avail);
1914//        cout << "here" << endl;
1915      int bytes_left = chars_read - chars_avail;
1916     
1917      //////////////////
1918      //element name buffer, for scanning element name backwards
1919      /////////////////
1920      memmove(&element_name_buffer[0],&src_buffer[SEGMENT_SIZE-ELEMENT_BUFFER_SIZE],ELEMENT_BUFFER_SIZE);
1921//      fprintf(gid_writein,"name_buffer\n");
1922      cross_buffer_flag = 1;
1923     
1924      memmove(&src_buffer[0], &src_buffer[SEGMENT_SIZE], LOOKAHEAD_SIZE);
1925      chars_read = fread(&src_buffer[LOOKAHEAD_SIZE],1,SEGMENT_SIZE, infile) + LOOKAHEAD_SIZE;
1926      chars_avail = chars_read;
1927//      cout << "here" << endl;
1928      if (chars_avail > SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
1929      buffer_pos += chars_avail;
1930      buffer_base = buffer_pos;
1931      block_segment_num++;
1932
1933  }
1934       
1935/* Final Partial Buffer */
1936    PERF_SEC_START(parser_timer);
1937
1938    block_pos = 0;
1939    int remaining = chars_avail;
1940
1941
1942
1943/* Full Blocks */
1944    while (remaining >= BLOCK_SIZE) {
1945          block_base = block_pos;
1946          s2p_do_block((BytePack *) &src_buffer[block_pos], basis_bits);
1947         
1948          @block_stmts
1949         
1950          tracker.StoreNewlines(lex.LF);
1951//        cout << "post start1" << endl;
1952         
1953//        postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
1954          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
1955          vectoring(tag_Callouts,hash_data,(char *)&src_buffer[0],block_base);
1956//        cout << "post end2" << endl;
1957          #ifndef STL_ALIGNED_VECTOR
1958          matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
1959          #endif
1960          tracker.AdvanceBlock();
1961          block_pos += BLOCK_SIZE;
1962          remaining -= BLOCK_SIZE;
1963    }
1964    block_base = block_pos;
1965        #ifdef USE_ANY_CARRY_TEST
1966    if (remaining > 0 || @any_carry) {
1967        #endif
1968          EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
1969          s2p_do_final_block((BytePack *) &src_buffer[block_pos], basis_bits, EOF_mask);
1970          @final_block_stmts
1971//        cout << "post start3" << endl;
1972//        postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
1973          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
1974          vectoring(tag_Callouts,hash_data,(char *)&src_buffer[0],block_base);
1975//        cout << "post end3" << endl;
1976          #ifndef STL_ALIGNED_VECTOR
1977      matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
1978          #endif
1979          tracker.AdvanceBlock();
1980        #ifdef USE_ANY_CARRY_TEST
1981    }
1982    #endif
1983    buffer_pos += chars_avail;
1984    buffer_base = buffer_pos;
1985        #ifndef STL_ALIGNED_VECTOR
1986    matcher.StreamScan(chars_avail);
1987    matcher.Advance_buffer();
1988//    tracker.Advance_buffer();
1989
1990   
1991    if (matcher.depth != 0) {
1992      fprintf(stderr, "tag matching error (depth %i) at position %i\n", matcher.depth, buffer_base);
1993      exit(-1);
1994     
1995     
1996    }
1997    #endif
1998    PERF_SEC_END(parser_timer, chars_avail);
1999//  print_GIDS();
2000//    pbgs_symbol_table.Print_Symbol_Table_Distribution();
2001}
2002
2003
2004
2005int
2006main(int argc, char * argv[]) {
2007        char * infilename, * outfilename;
2008        FILE *infile, *outfile;
2009        struct stat fileinfo;
2010
2011        if (argc < 2) {
2012                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
2013                exit(-1);
2014        }
2015
2016        infilename = argv[1];
2017        stat(infilename, &fileinfo);
2018        infile = fopen(infilename, "rb");
2019        if (!infile) {
2020                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
2021                exit(-1);
2022        }
2023
2024        if (argc < 3) outfile = stdout;
2025        else {
2026                outfilename = argv[2];
2027                outfile = fopen(outfilename, "wb");
2028                if (!outfile) {
2029                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
2030                        exit(-1);
2031                }
2032        }
2033
2034//      PERF_SEC_BIND(1);
2035
2036        PERF_SEC_INIT(parser_timer);
2037
2038        do_process(infile, outfile);
2039       
2040#if DEBUG
2041//print_gid_vec();
2042#endif
2043        //cout << "validate start" << endl;
2044        //validate();
2045#ifdef CONTENT_MODEL
2046        validate_mul_block();
2047#endif
2048        PERF_SEC_DUMP(parser_timer);
2049
2050        PERF_SEC_DESTROY(parser_timer);
2051
2052        fclose(infile);
2053        fclose(outfile);
2054
2055        printf ("Done procressing\n");
2056        return(0);
2057}
Note: See TracBrowser for help on using the repository browser.