source: proto/xmlschema/validation_template_onevec_po.cpp @ 4223

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

test case updated

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