source: proto/xmlschema/validation_template_onevec.cpp @ 3730

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

check in template file

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