source: proto/xmlschema/validation_template_onevec.cpp @ 3292

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

template modified

File size: 42.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 DEBUG 1
17//#define BLOCK_SIZE (sizeof(SIMD_type) * 8)
18//#define SEGMENT_BLOCKS 12
19//#define BUFFER_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
20//#define OVERLAP_BUFSIZE 2*(sizeof(SIMD_type))
21
22#define VECTOR_WIDTH 8
23#define VECTOR_TYPE (char)
24
25#include <stdio.h>
26#include <stdlib.h>
27#include <errno.h>
28#include <sys/types.h>
29#include <sys/stat.h>
30#include <limits.h>
31
32#include <simd-lib/s2p.hpp>
33#include <simd-lib/buffer.hpp>
34#include <simd-lib/bitblock_iterator.hpp>
35#include <simd-lib/perflib/perfsec.h>
36
37//#include "../lib/lib_simd.h"
38#include "../symtab/pbgs_identity_symbol_table.h"
39
40#include <stack>
41#include <map>
42#include <vector>
43
44#include <queue>
45#include <string>
46
47typedef long ScanBlock;
48typedef BytePack BitBlock;
49
50using namespace std;
51
52//#include "../lib/carryQ.h"
53#include <xmldecl.h>
54//#include "xml_error.c"
55//#include "xmldecl.c"
56#include <namechars.h>
57#include <LineColTracker.hpp>
58#include <XMLTestSuiteError.h>
59
60// Define the mappings for pablo.assert_0(strm, errkind) statements which
61// compile to the the form assert_0_error(errkind, strm)
62#include <ErrorTracker.h>
63
64ErrorTracker error_tracker;
65#define assert_0_error(errkind, errstrm) error_tracker.NoteError(errkind, errstrm);
66
67#ifndef STL_ALIGNED_VECTOR
68#include <TagMatcher.hpp>
69#endif
70
71#ifdef STL_ALIGNED_VECTOR // experimental, comment out TagMatcher code to use STL aligned memory vector
72#warning "Compiling with experimental STL_ALIGNED_VECTOR."
73#include <vector>
74#include <simd-lib/stl_aligned_allocator.hpp>
75#endif
76
77#ifdef BUFFER_PROFILING
78        BOM_Table * parser_timer;
79
80#elif CODE_CLOCKER
81        #define NUM_EVENTS 1
82        int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
83        //int Events[NUM_EVENTS] = {PAPI_L2_DCM};
84        //int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
85        int cal_size = 20;
86        CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
87#else
88        void * parser_timer;
89#endif
90
91//////////////////////////////////////////////////////////////////////////////////////////
92// Buffer Management // WARNING: Do Not update #defines. Results in TagMatcher errors.
93//////////////////////////////////////////////////////////////////////////////////////////
94#define PADDING_BLOCKS 0
95#define PADDING_SIZE (BLOCK_SIZE * PADDING_BLOCKS)
96#define COPYBACK_BLOCKS 2
97#define COPYBACK_SIZE (BLOCK_SIZE * COPYBACK_BLOCKS)
98#define LOOKAHEAD_BLOCKS 1
99#define LOOKAHEAD_SIZE (BLOCK_SIZE * LOOKAHEAD_BLOCKS)
100#define SEGMENT_BLOCKS  12 // WARNING: TagMatcher.hpp causes xmlconf test suite failures for SEGMENT_BLOCKS < 3.
101#define SEGMENT_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
102#define BUFFER_SIZE (COPYBACK_SIZE + SEGMENT_SIZE + LOOKAHEAD_SIZE + PADDING_SIZE)
103
104
105
106//int block_base=0;
107//int buffer_base=0;
108int buffer_last;
109FILE *gid_writein;
110#define ELEMENT_BUFFER_SIZE 30
111char element_name_buffer[ELEMENT_BUFFER_SIZE];
112int cross_buffer_flag = 0;
113//char * source;
114LineColTracker tracker;
115
116static inline int cfzl(long x){
117        unsigned long ux = x;
118        if (x<0){
119                ux = ULONG_MAX + x + 1;
120        }
121        if (ux==0)
122                return 8*sizeof(long);
123        int n;
124        n = 0;
125        while (1){
126                if ((ux%2) == 1){
127                        if(n==64){
128                                cout << ux <<endl;
129                        }
130                        return n;               
131                }
132                n ++;
133                ux = ux >> 1;
134                //cout << "x = " << x << endl;
135        } 
136}
137
138static inline void print_gid_vec();
139/*
140static inline int cfzl(long x){
141 if (x ==0)
142  return 32;
143 int n=0;
144 if ((x & 0xFFFF0000) == 0) { n += 16; x =x << 16;} //1111 1111 1111 1111 0000 0000 0000 0000 // 16 bits from left are zero! so we omit 16left bits
145 if ((x & 0xFF000000) == 0){ n = n +  8; x = x <<  8;} // 8 left bits are 0
146 if ((x & 0xF0000000) ==0){ n = n +  4; x = x <<  4;} // 4 left bits are 0
147 if ((x & 0xC0000000) == 0){ n =n +  2, x = x <<  2;}  // 110000....0 2 left bits are zero
148 if ((x & 0x80000000) == 0){n = n +  1, x = x <<  1;} // first left bit is zero
149 return n;
150
151}
152*/
153static inline void ReportError(const char * error_msg, int error_pos_in_block) {
154  int error_line, error_column;
155  tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
156  fprintf(stderr, "%s at line %i, column %i\n", error_msg, error_line, error_column);
157}
158/*
159class ErrorTracker {
160public:
161    ErrorTracker() { noted_pos_in_block = -1;}
162
163    inline void NoteError(const char * error_msg, BitBlock err_strm) {
164      int pos_in_block = count_forward_zeroes(err_strm);
165      if ((noted_pos_in_block == -1) || (noted_pos_in_block > pos_in_block)) {
166        noted_pos_in_block = pos_in_block;
167        noted_error = error_msg;
168      }
169    }
170
171    inline void If_Error_Report_First() {
172      if (noted_pos_in_block > -1) {
173              int error_line, error_column;
174              ReportError(noted_error, noted_pos_in_block);
175              exit(-1);
176      }
177    }
178
179private:
180  const char * noted_error;
181  int noted_pos_in_block;
182};
183*/
184
185
186//BitBlock EOF_mask = simd_const_1(1);
187
188//ErrorTracker error_tracker;
189BitBlock elem_starts;
190int previous_block_last_elem_start;
191BytePack hashvalues[2];
192
193vector <int> gids;
194PBGSIdentitySymbolTable pbgs_symbol_table;
195
196vector <char> gid_vec;
197
198stack <vector<char>* > elem_vec_stack;
199map<char, vector<char>* > elem_vec_map;
200
201static inline int ScanBackwardPos(BitBlock * block, int pos)
202{
203        cout << "pos " << pos << endl;
204    BitBlock s = block[0];
205    if (bitblock::any(block[0])){
206        print_register("zero",block[0]);
207        print_register("t",simd_not(simd<128>::sll(simd<1>::constant<1>(), convert(pos))) );
208        }
209    BitBlock temp = simd_and( s, simd_not(simd<128>::sll(simd<1>::constant<1>(), convert(pos))) );
210//      print_register("zero",simd_not(simd<128>::sll(simd<1>::constant<1>());
211                print_register("temp",temp);
212    if (bitblock::any(temp))
213    {
214        // sizeof (BitBlock)*8 - cbzl( s & ~(~0 << pos)) - 1;
215//      cout << "block_size" << BLOCK_SIZE << endl;
216        return BLOCK_SIZE - count_reverse_zeroes(temp) - 1;
217    }
218    else
219    {
220        //handle boundary case
221        return previous_block_last_elem_start - 1;
222    }
223}
224
225static inline int StreamScan(ScanBlock * stream, int blk_count, int ProcessPos(int)) {
226        int blk;
227        int block_pos = 0;
228        for (blk = 0; blk < blk_count; blk++) {
229                ScanBlock s = stream[blk];
230                while(s) {
231                        int code = (ProcessPos(cfzl(s) + block_pos));
232                        if (code) return code;
233                        s = s & (s-1);  // clear rightmost bit.
234                }
235                block_pos += 8 * sizeof(ScanBlock);
236        }
237        return 0;
238}
239
240static inline int compute_hash_value2(char *str,int lgth){
241        int hash = 5381;
242    int c;
243//      while (c = *str++){
244        for (int i = 0;i<lgth;i++){
245                c=*str++; 
246        hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
247    }
248
249    return hash;
250}
251
252static inline int compute_hash_value (int lgth, int start)
253{
254    unsigned int offset_bit = start + 128;
255    uint64_t stream = *((uint64_t*)(((uint32_t*)hashvalues)+(offset_bit>>5)));
256    return stream >> (offset_bit & 0x1F) & ~(~0 << lgth);
257}
258/*
259template <int L>
260static inline int ElemEnd_grouping(int pos) {
261    int end = block_base + pos;
262    int start = end - L;
263    int hashvalue = compute_hash_value(L, start - block_base);
264    int gid = pbgs_symbol_table.Lookup_or_Insert_Name<L>(source + start, hashvalue);
265    gids.push_back(gid);
266#if DEBUG
267    char* symbol = new char[L+1];
268    strncpy ( symbol, source + start, L );
269    symbol[L] ='\0';
270    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 );
271    delete symbol; symbol = 0;
272#endif
273    return gid;
274}
275
276template<>
277inline int ElemEnd_grouping<17>(int pos) {
278    int end = block_base + pos;
279    int start = ScanBackwardPos (&elem_starts, pos) + block_base;
280    int lgth = end - start;
281    int hashvalue = compute_hash_value(lgth, start - block_base);
282    int gid = 0;
283
284//    if (lgth < 32)
285//    {
286//      gid = pbgs_symbol_table.Lookup_or_Insert_Name_32(source + start, hashvalue, lgth);
287//    }
288//    else
289    {
290        gid = pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
291    }
292    gids.push_back(gid);
293#if DEBUG
294    char* symbol = new char[lgth+1];
295    strncpy ( symbol, source + start, lgth );
296    symbol[lgth] ='\0';
297    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);
298#endif
299    return gid;
300}
301*/
302
303inline char ElemEnd_grouping(char *source,int block_base,int pos) {
304    int end = block_base + pos;
305    int start = ScanBackwardPos(&elem_starts, pos) + block_base;
306    ///////////////////////
307    //start could be negitive
308    //the element name falls in two buffers
309    ///////////////////////
310    char *name = source + start;
311    char name_buffer[50];
312   
313    if (start<0){
314        memmove (&name_buffer[0],&element_name_buffer[ELEMENT_BUFFER_SIZE+start],-start);       
315        memmove (&element_name_buffer[ELEMENT_BUFFER_SIZE+start],&source[0],50+start);
316        name = name_buffer;
317    }
318//    cout << end << "  " << start << endl;
319    int lgth = end - start;
320//    int hashvalue = compute_hash_value(lgth,start-block_base);
321        int hashvalue = compute_hash_value2(name,lgth);
322    char gid = 0;
323
324
325//    if (lgth < 32)
326//    {
327//      gid = pbgs_symbol_table.Lookup_or_Insert_Name_32(source + start, hashvalue, lgth);
328//    }
329//    else
330
331        switch (lgth)
332    {
333    case 1:
334        gid = pbgs_symbol_table.Lookup_or_Insert_Name<1>(source + start, hashvalue);
335        break;
336    case 2:
337        gid = pbgs_symbol_table.Lookup_or_Insert_Name<2>(source + start, hashvalue);
338        break;
339    case 3:
340        gid = pbgs_symbol_table.Lookup_or_Insert_Name<3>(source + start, hashvalue);
341        break;
342    case 4:
343        gid = pbgs_symbol_table.Lookup_or_Insert_Name<4>(source + start, hashvalue);
344        break;
345    case 5:
346        gid = pbgs_symbol_table.Lookup_or_Insert_Name<5>(source + start, hashvalue);
347        break;
348    case 6:
349        gid = pbgs_symbol_table.Lookup_or_Insert_Name<6>(source + start, hashvalue);
350        break;
351    case 7:
352        gid = pbgs_symbol_table.Lookup_or_Insert_Name<7>(source + start, hashvalue);
353        break;
354    case 8:
355        gid = pbgs_symbol_table.Lookup_or_Insert_Name<8>(source + start, hashvalue);
356        break;
357    case 9:
358        gid = pbgs_symbol_table.Lookup_or_Insert_Name<9>(source + start, hashvalue);
359        break;
360    case 10:
361        gid = pbgs_symbol_table.Lookup_or_Insert_Name<10>(source + start, hashvalue);
362        break;
363    case 11:
364        gid = pbgs_symbol_table.Lookup_or_Insert_Name<11>(source + start, hashvalue);
365        break;
366    case 12:
367        gid = pbgs_symbol_table.Lookup_or_Insert_Name<12>(source + start, hashvalue);
368        break;
369    case 13:
370        gid = pbgs_symbol_table.Lookup_or_Insert_Name<13>(source + start, hashvalue);
371        break;
372    case 14:
373        gid = pbgs_symbol_table.Lookup_or_Insert_Name<14>(source + start, hashvalue);
374        break;
375    case 15:
376        gid = pbgs_symbol_table.Lookup_or_Insert_Name<15>(source + start, hashvalue);
377        break;
378    case 16:
379        gid = pbgs_symbol_table.Lookup_or_Insert_Name<16>(source + start, hashvalue);
380        break;
381    default:
382        gid = pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
383        break;
384    }
385/*
386    {
387        gid = (char)pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
388    }
389*/
390    gids.push_back(gid);
391#if DEBUG
392    char* symbol = new char[lgth+1];
393    strncpy ( symbol, source + start, lgth );
394    symbol[lgth] ='\0';
395    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);
396    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);
397#endif
398    return gid;
399}
400
401//template <int L>
402static inline int StreamScanLengthGrouping(char *source,int block_base,ScanBlock * stream, ScanBlock * stream2, int blk_count) {
403    int blk;
404    int block_pos = 0;
405//    cout << "cfzl():" << cfzl() << endl;
406//      long test = 6;
407//      test = (test & (test - 1));
408//      cout << test << endl;
409    for (blk = 0; blk < blk_count; blk++) {
410        cout << "blk:" << blk << endl;
411   
412                ScanBlock s = stream[blk];
413                ScanBlock s2 = stream2[blk];
414//              cout << s << "  " << s2 << endl;
415//              print_register("s:",((BitBlock*)stream)[0]);
416                while(s | s2) {
417                        cout << "cfzl(s):" << cfzl(s)<<endl;
418                    int end_pos = cfzl(s) + block_pos;
419//                  cout << "s2 " << s2 << endl;
420                    int end_tag = cfzl(s2) + block_pos;
421//              cout << "cfzl(s):" << cfzl(s)<<endl;
422//              cout << "cfzl(s2):" << cfzl(s2)<<endl;
423//                      cout << (end_tag < end_pos && s2 != 0)<< "||" <<(s == 0 && s2 != 0)  << endl;
424                        if ((end_tag < end_pos && s2 != 0) | (s == 0 && s2 != 0)){
425                        cout << "here" << endl;
426                        cout << "closing tag" << endl;
427//                      cout << "endtag:" << end_tag << " " << end_pos<<endl;
428//                      cout << "1"<< endl;
429//                      cout << elem_vec_stack.size()<<endl;
430//                      cout << "2" << endl;
431//                      cout << elem_vec_stack.top()<<endl;
432                                if(!(gid_vec.empty())){
433//                                      if(gid_vec.back() != 0){
434                                                gid_vec.push_back(0);
435//                                      }
436                                }
437                                cout << "before" << s2 << endl;
438                                s2 = s2 & (s2 - 1);
439                                cout << "after" << s2 << endl;
440//                      cout << "s2 = " << s2 << endl;
441                }else{
442                        cout << " end_pos == " << end_pos<<endl;
443                        cout << " end_tag_pos == " << end_tag << endl;
444                        char gid = ElemEnd_grouping(source,block_base,end_pos);
445                        if (s!=0){
446                                s = s & (s-1);  // clear rightmost bit.
447                        }
448                        //else{
449                        //      s2 = s2 & (s2 - 1);
450                        //}
451                                if (gid != 0){
452                                        gid_vec.push_back(gid);                 
453                                }
454                                cout << "here1" << endl;
455                }
456                }
457                block_pos += 8 * sizeof(ScanBlock);
458                print_gid_vec();
459    }
460    return 0;
461}
462
463void print_gid_vec(){
464        for (int i = 0; i < gid_vec.size(); i++){
465                cout << (int)gid_vec[i] << " ";
466        }
467        cout << endl;
468/*     
469        int i = 1;
470        int lst[256] = {0};
471        cout << elem_vec_map.size() << " vectors" << endl;
472        for (int i = 0;i < gids.size(); i++){
473                if (lst[gids[i]] == 0){
474                        cout << "gid: " << gids[i] << endl;
475                        lst[gids[i]] = 1;
476                        vector<char> *tmp = elem_vec_map[gids[i]];
477                        cout << "vector size:"<< (*tmp).size()<<endl;
478                        if ((*tmp).size()!=0){
479                                cout << "elements: ";
480                                for (int j = 0; j < (*tmp).size();j++){
481                                        cout << (int)(*tmp)[j] << " ";
482                                }
483                                cout << endl;
484                        }
485                        cout << endl;
486                }
487        }
488*/
489}
490/*
491static inline int NameStrt_check(int pos) {
492        int block_pos = block_base + pos;
493        if(XML_10_UTF8_NameStrt_bytes((unsigned char*)&source[block_pos]) == 0){
494              ReportError("name start error", pos);
495              exit(-1);
496        }
497        return 0;
498}
499
500static inline int Name_check(int pos) {
501        int block_pos = block_base + pos;
502        if(XML_10_UTF8_NameChar_bytes((unsigned char*)&source[block_pos]) == 0){
503              ReportError("name error", pos);
504              exit(-1);
505        }
506        return 0;
507}
508
509static inline int PIName_check(int pos) {
510        int block_pos = block_base + pos;
511        int file_pos = block_pos+buffer_base;
512        printf ("%s:%i\n",__FUNCTION__,pos);
513        if (at_XxMmLll<ASCII>((unsigned char*)&source[block_pos]) && (source[block_pos+3]=='?' || source[block_pos+3]<= ' ')) {
514              // "<?xml" legal at start of file.
515              if ((file_pos == 2) && at_XmlDecl_start<ASCII>((unsigned char*)&source[0])) return 0;
516              ReportError("[Xx][Mm][Ll] illegal as PI name", pos);
517              exit(-1);
518        }
519        return 0;
520}
521
522static inline int CD_check(int pos) {
523        int block_pos = block_base + pos;
524        if (!at_CDATA1<ASCII>((unsigned char*)&source[block_pos])){
525              ReportError("CDATA error", pos);
526              exit(-1);
527        }
528        return 0;
529}
530
531static inline int GenRef_check(int pos) {
532        int block_pos = block_base + pos;
533        unsigned char* s = (unsigned char*)&source[block_pos];
534        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))){
535                        cout << pos << endl;
536              ReportError("Undefined reference", pos);
537              exit(-1);
538        }
539        return 0;
540}
541
542static inline int HexRef_check(int pos) {
543        int block_pos = block_base + pos;
544        unsigned char* s = (unsigned char*)&source[block_pos];
545        int ch_val = 0;
546        while(at_HexDigit<ASCII>(s)){
547          ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
548          if (ch_val> 0x10FFFF ){
549            ReportError("Illegal character reference", pos);
550            exit(-1);
551          }
552          s++;
553        }
554        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
555          ReportError("Illegal character reference", pos);
556          exit(-1);
557        }
558        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
559          ReportError("Illegal XML 1.0 character reference", pos);
560          exit(-1);
561        }
562        return 0;
563}
564
565static inline int DecRef_check(int pos) {
566        int block_pos = block_base + pos;
567        unsigned char* s = (unsigned char*)&source[block_pos];
568        int ch_val = 0;
569        while(at_HexDigit<ASCII>(s)){
570          ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
571          if (ch_val> 0x10FFFF ){
572            ReportError("Illegal character reference", pos);
573            exit(-1);
574          }
575          s++;
576        }
577        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
578          ReportError("Illegal character reference", pos);
579          exit(-1);
580        }
581        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
582          ReportError("Illegal XML 1.0 character reference", pos);
583          exit(-1);
584        }
585        return 0;
586}
587
588static inline int AttRef_check(int pos) {
589        int block_pos = block_base + pos;
590        unsigned char* s = (unsigned char*)&source[block_pos];
591        int ch_val = 0;
592        if(s[0]=='#'){
593          s++;
594          if(s[0]=='x' || s[0]=='X'){
595            s++;
596            while(at_HexDigit<ASCII>(s)){
597              ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
598              s++;
599            }
600          }
601          else{
602            while(at_HexDigit<ASCII>(s)){
603              ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
604              s++;
605            }
606          }
607          if (ch_val==60){
608            ReportError("Attribute values contain '<' characters after reference expansion", pos);
609            exit(-1);
610          }
611        }
612        else if(at_Ref_lt<ASCII>(s)){
613          ReportError("Attribute values contain '<' characters after reference expansion", pos);
614          exit(-1);
615        }
616        return 0;
617}
618*/
619
620
621
622@global
623
624#include <simd-lib/transpose.hpp>
625#include <post_process.hpp>
626/*
627static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
628  s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
629        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);
630}
631
632static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask) {
633  s2p_do_block(U8, basis_bits);
634  basis_bits.bit_0 = simd_and(basis_bits.bit_0, EOF_mask);
635  basis_bits.bit_1 = simd_and(basis_bits.bit_1, EOF_mask);
636  basis_bits.bit_2 = simd_and(basis_bits.bit_2, EOF_mask);
637  basis_bits.bit_3 = simd_and(basis_bits.bit_3, EOF_mask);
638  basis_bits.bit_4 = simd_and(basis_bits.bit_4, EOF_mask);
639  basis_bits.bit_5 = simd_and(basis_bits.bit_5, EOF_mask);
640  basis_bits.bit_6 = simd_and(basis_bits.bit_6, EOF_mask);
641  basis_bits.bit_7 = simd_and(basis_bits.bit_7, EOF_mask);
642}
643*/
644static inline void print_basis_bits(Basis_bits & basis_bits){
645        print_register("bit0:",basis_bits.bit_0);
646        print_register("bit1:",basis_bits.bit_1);
647        print_register("bit2:",basis_bits.bit_2);
648        print_register("bit3:",basis_bits.bit_3);
649        print_register("bit4:",basis_bits.bit_4);
650        print_register("bit5:",basis_bits.bit_5);
651        print_register("bit6:",basis_bits.bit_6);
652        print_register("bit7:",basis_bits.bit_7);                                       
653}
654
655static inline void print_elem_vec(vector<char>* vec, int size){
656        cout << "vector: ";
657        for (int i = 0; i<size ; i++){
658                cout << (int)(*vec)[i] <<" ";
659        }
660        cout << endl;
661}
662
663
664static inline void validate(){
665        struct Elem elem;
666        Validation_1 validation_1;
667        struct Lex lex;
668        struct Output output;
669        Classify_bytes classify_bytes;
670        cout << "vector size " << gid_vec.size() << endl;
671        int lgth = gid_vec.size();
672        int remaining = 0;
673        int current_pos = 0;
674        Basis_bits temp_basis_bits;
675
676        ForwardScanner<BitBlock, ScanWord> match_scanner;
677        ReverseScanner<BitBlock, ScanWord> vec_scanner;
678        ForwardScanner<BitBlock, ScanWord> f_vec_scanner;
679        int block_base = 0;
680        if (lgth != 0){
681                int i = 0;
682                int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
683                remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
684                for (i = 0;i < num_block; i++){
685//                      s2p_do_block((BytePack*)(vector_11[i]),temp_basis_bits);
686                        s2p_do_block((BytePack*)(&(gid_vec[i])), temp_basis_bits);
687                        print_elem_vec(&(gid_vec),lgth);
688                        print_basis_bits(temp_basis_bits);
689                       
690                        classify_bytes.do_block(temp_basis_bits,lex);
691                        validation_1.do_block(lex,output);
692                       
693                        match_scanner.init(&output.matches);
694                        vec_scanner.init(&lex.cc1);
695                        match_scanner.scan_to_next();
696                        f_vec_scanner.init(&lex.cc1);
697                        match_scanner.scan_to_next();
698                        f_vec_scanner.scan_to_next();
699                        current_pos = f_vec_scanner.get_pos();
700                        vec_scanner.move_to(match_scanner.get_pos());
701                        vec_scanner.scan_to_next();
702//                      cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
703                        if (vec_scanner.get_pos() != current_pos){
704                                printf("#Mismatch found at pos: %d.\n",current_pos+block_base);
705                        }
706//                      out = simd_or(out,lex.cc1);
707//                      print_register("out",out);
708                       
709                        while(!(match_scanner.is_done() || f_vec_scanner.is_done())){
710                                f_vec_scanner.scan_to_next();
711                                while(!(match_scanner.is_done())){
712                                        match_scanner.scan_to_next();
713                                        if(match_scanner.get_pos()>0){
714                                                vec_scanner.move_to(match_scanner.get_pos());
715                                                vec_scanner.scan_to_next();
716                                        }
717                                        if (vec_scanner.get_pos() != current_pos){
718                                                        break;
719                                        }
720                                }
721                                cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
722                                if (f_vec_scanner.get_pos()>0){
723                                        current_pos = f_vec_scanner.get_pos();
724                                }
725                                if (vec_scanner.get_pos() != current_pos){
726                                        printf("Mismatch found at pos: %d.\n",current_pos+block_base);
727                                }
728//                              out = simd_or(out,lex.cc1);
729//                              cout << "match_scanner_pos = " << match_scanner.get_pos() << endl;
730//                              cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
731//                              if(match_scanner.get_pos() == vec_scanner.get_pos()){
732//                                      printf("Match found of element with id of '1'\n");                             
733//                              }
734                        }
735                               
736                       
737//                      (BytePack*)(iter->second)
738//                      validate_Elem_Vec.do_block(elem, temp_basis_bits);
739                        cout << i ;
740                        block_base += BLOCK_SIZE;
741                }
742                if (remaining !=0){
743                        BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
744                        s2p_do_final_block((BytePack*)(&(gid_vec[i])), temp_basis_bits,EOF_mask);
745                        print_elem_vec(&(gid_vec),lgth);
746                        print_basis_bits(temp_basis_bits);
747                       
748                        classify_bytes.do_block(temp_basis_bits,lex);
749                        validation_1.do_block(lex,output);
750                        print_register("output.matches",output.matches);
751                        print_register("lex.cc1",lex.cc1);
752                        match_scanner.init(&output.matches);
753                        vec_scanner.init(&lex.cc1);
754                        f_vec_scanner.init(&lex.cc1);
755                        match_scanner.scan_to_next();
756                        f_vec_scanner.scan_to_next();
757                        current_pos = f_vec_scanner.get_pos();
758                        cout << "current_pos = " << current_pos << endl;
759//                      cout << "match_scanner_pos = " << match_scanner.get_pos()<< endl;
760//                      cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
761                        vec_scanner.move_to(match_scanner.get_pos());
762                        vec_scanner.scan_to_next();
763                        cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
764                        if (vec_scanner.get_pos() != current_pos){
765                                printf("#Mismatch found at pos: %d.\n",current_pos+block_base);
766                        }
767//                      out = simd_or(out,lex.cc1);
768//                      print_register("out",out);
769                       
770                        while(!(match_scanner.is_done() || f_vec_scanner.is_done())){
771                                f_vec_scanner.scan_to_next();
772                                while(!(match_scanner.is_done())){
773                                        match_scanner.scan_to_next();
774                                        if(match_scanner.get_pos()>0){
775                                                vec_scanner.move_to(match_scanner.get_pos());
776                                                vec_scanner.scan_to_next();
777                                        }
778                                        if (vec_scanner.get_pos() != current_pos){
779                                                        break;
780                                        }
781                                }
782                                cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
783                                if (f_vec_scanner.get_pos()>0){
784                                        current_pos = f_vec_scanner.get_pos();
785                                }
786                                if (vec_scanner.get_pos() != current_pos){
787                                        printf("Mismatch found at pos: %d.\n",current_pos+block_base);
788                                }
789//                              out = simd_or(out,lex.cc1);
790//                              cout << "match_scanner_pos = " << match_scanner.get_pos() << endl;
791//                              cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
792//                              if(match_scanner.get_pos() == vec_scanner.get_pos()){
793//                                      printf("Match found of element with id of '1'\n");                             
794//                              }
795                        }
796//                      validate_Elem_Vec.do_final_block(elem, temp_basis_bits, EOF_mask);
797                }
798        }
799/*
800        vector<int> test;
801        for(int i = 1;i <12; i++){
802                test.push_back(i);
803        }
804//      int test[] = {1,2,3,4,5,6,7,8,9,10,11};
805        Basis_bits temp_basis_bits;
806        BitBlock EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-44));
807        s2p_do_final_block((BytePack*)(&(test[0])), temp_basis_bits,EOF_mask);
808        print_basis_bits(temp_basis_bits);
809*/
810/*
811        for (map<char, vector<char>* > ::const_iterator iter = elem_vec_map.begin(); iter!= elem_vec_map.end(); ++iter){
812                int i = 0;
813                int lgth = (*(iter->second)).size();
814                int remaining;
815                if (lgth != 0){
816                        cout <<"vector key "<< (int)iter->first << endl;
817//                      cout <<"vector ptr" << iter->second<<endl;
818               
819                        cout <<"vector size: " << lgth << endl;
820                        int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
821                        remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
822                        for (i = 0;i < num_block; i++){
823                                Basis_bits temp_basis_bits;
824                                s2p_do_block(((BytePack*)(&(*(iter->second))[i])), temp_basis_bits);
825                                print_elem_vec(iter->second,lgth);
826                                print_basis_bits(temp_basis_bits);
827//                              (BytePack*)(iter->second)
828                                cout << i ;
829                        }
830                        cout << endl;
831                        if (remaining !=0){
832                                BitBlock EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-remaining));
833                                Basis_bits temp_basis_bits;
834                                s2p_do_final_block(((BytePack*)(&(*(iter->second))[i])), temp_basis_bits,EOF_mask);
835                                print_elem_vec((iter->second)+i,lgth);
836                                print_basis_bits(temp_basis_bits);
837                        }
838                }                       
839        }
840*/
841}
842
843static inline void vectoring(Tag_Callouts & tag_Callouts, Hash_data & hash_data,char *source,int block_base){
844
845        elem_starts = tag_Callouts.ElemName_starts;
846    hashvalues[1] = hash_data.Hash_value;
847   
848        StreamScanLengthGrouping(source,block_base,(ScanBlock *) &tag_Callouts.ElemName_ends,(ScanBlock *) &tag_Callouts.Tag_closing, sizeof(BitBlock)/sizeof(ScanBlock));
849       
850        // Store the last starting position in case we hit boundary case
851    previous_block_last_elem_start = - count_reverse_zeroes(elem_starts);
852
853    //copy current hash value data as previous one.
854    memmove (&hashvalues[0], &hashvalues[1], 16);
855}
856/*
857static 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){
858
859
860    //NOTE: We are NOT handling the case for an extremely long symbol name (length > 1541).
861    //      TagMatcher will crash if we feed a long symbol name.
862    //      Sample file: test/long_sym_name.xml
863
864    tracker.StoreNewlines(lex.LF);
865    elem_starts = tag_Callouts.ElemName_starts;
866    hashvalues[1] = hash_data.Hash_value;
867
868        StreamScanLengthGrouping((ScanBlock *) &tag_Callouts.ElemName_ends,(ScanBlock *) &tag_Callouts.Tag_closing, sizeof(BitBlock)/sizeof(ScanBlock));
869       
870/*
871    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_1) )
872    {
873        StreamScanLengthGrouping<1>((ScanBlock *) &tag_Callouts.ElemName_ends_1,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
874    }
875
876    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_2) )
877    {
878        StreamScanLengthGrouping<2>((ScanBlock *) &tag_Callouts.ElemName_ends_2,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
879    }
880
881    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_3) )
882    {
883        StreamScanLengthGrouping<3>((ScanBlock *) &tag_Callouts.ElemName_ends_3,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
884    }
885
886    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_4) )
887    {
888        StreamScanLengthGrouping<4>((ScanBlock *) &tag_Callouts.ElemName_ends_4,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
889    }
890
891    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_5) )
892    {
893        StreamScanLengthGrouping<5>((ScanBlock *) &tag_Callouts.ElemName_ends_5,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
894    }
895
896    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_6) )
897    {
898        StreamScanLengthGrouping<6>((ScanBlock *) &tag_Callouts.ElemName_ends_6,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
899    }
900
901    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_7) )
902    {
903        StreamScanLengthGrouping<7>((ScanBlock *) &tag_Callouts.ElemName_ends_7,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
904    }
905
906    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_8) )
907    {
908        StreamScanLengthGrouping<8>((ScanBlock *) &tag_Callouts.ElemName_ends_8,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
909    }
910
911    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_9) )
912    {
913        StreamScanLengthGrouping<9>((ScanBlock *) &tag_Callouts.ElemName_ends_9,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
914    }
915
916    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_10) )
917    {
918        StreamScanLengthGrouping<10>((ScanBlock *) &tag_Callouts.ElemName_ends_10,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
919    }
920
921    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_11) )
922    {
923        StreamScanLengthGrouping<11>((ScanBlock *) &tag_Callouts.ElemName_ends_11,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
924    }
925
926    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_12) )
927    {
928        StreamScanLengthGrouping<12>((ScanBlock *) &tag_Callouts.ElemName_ends_12,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
929    }
930
931    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_13) )
932    {
933        StreamScanLengthGrouping<13>((ScanBlock *) &tag_Callouts.ElemName_ends_13,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
934    }
935
936    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_14) )
937    {
938        StreamScanLengthGrouping<14>((ScanBlock *) &tag_Callouts.ElemName_ends_14,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
939    }
940
941    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_15) )
942    {
943        StreamScanLengthGrouping<15>((ScanBlock *) &tag_Callouts.ElemName_ends_15,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
944    }
945
946    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_16) )
947    {
948        StreamScanLengthGrouping<16>((ScanBlock *) &tag_Callouts.ElemName_ends_16,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
949    }
950
951    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_17_and_longer) )
952    {
953        StreamScanLengthGrouping<17>((ScanBlock *) &tag_Callouts.ElemName_ends_17_and_longer,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
954    }
955
956*/
957
958
959/*
960    // Store the last starting position in case we hit boundary case
961    previous_block_last_elem_start = - count_reverse_zeroes(elem_starts);
962
963    //copy current hash value data as previous one.
964    memmove (&hashvalues[0], &hashvalues[1], 16);
965
966    if (bitblock::any(simd_or(check_streams.non_ascii_name_starts, check_streams.non_ascii_names))) {
967      StreamScan((ScanBlock *) &check_streams.non_ascii_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), NameStrt_check);
968      StreamScan((ScanBlock *) &check_streams.non_ascii_names, sizeof(BitBlock)/sizeof(ScanBlock), Name_check);
969    }
970
971    if (bitblock::any(ctCDPI_Callouts.PI_name_starts)){
972      StreamScan((ScanBlock *) &ctCDPI_Callouts.PI_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), PIName_check);
973    }
974
975    if (bitblock::any(ctCDPI_Callouts.CD_starts)){
976      StreamScan((ScanBlock *) &ctCDPI_Callouts.CD_starts, sizeof(BitBlock)/sizeof(ScanBlock), CD_check);
977    }
978
979    if (bitblock::any(ref_Callouts.GenRef_starts)){
980      StreamScan((ScanBlock *) &ref_Callouts.GenRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), GenRef_check);
981    }
982
983    if (bitblock::any(ref_Callouts.DecRef_starts)){
984      StreamScan((ScanBlock *) &ref_Callouts.DecRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), DecRef_check);
985    }
986
987    if (bitblock::any(ref_Callouts.HexRef_starts)){
988      StreamScan((ScanBlock *) &ref_Callouts.HexRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), HexRef_check);
989    }
990
991    if (bitblock::any(check_streams.att_refs)){
992      StreamScan((ScanBlock *) &check_streams.att_refs, sizeof(BitBlock)/sizeof(ScanBlock), AttRef_check);
993    }
994
995//    error_tracker.If_Error_Report_First();
996/*
997    matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
998    tracker.AdvanceBlock();
999    */
1000    /*
1001}
1002*/
1003
1004static inline void print_GIDS()
1005{
1006    int span_count = gids.size();
1007    for(int i=0;i<span_count;i++) {
1008             cout << gids[i] << " ";
1009    }
1010    cout << endl;
1011}
1012
1013static inline int test(int)
1014{
1015    return 0;
1016}
1017
1018void do_process(FILE *infile, FILE *outfile) {
1019
1020        ///////////////
1021        //gid file
1022        ///////////////
1023        gid_writein = fopen("gid.out","w");
1024@decl
1025        #ifndef STL_ALIGNED_VECTOR
1026                TagMatcher<SEGMENT_SIZE,LOOKAHEAD_SIZE> matcher;
1027        #endif
1028        ///////////////////////////////////////////////////
1029        //preload element_IDs into symbol table from schema
1030        ///////////////////////////////////////////////////
1031        FILE *element_ID_in = fopen("../test/element_ID","r");
1032        char symbol[50];
1033        int index;
1034        if(element_ID_in == NULL){
1035                printf("Error opening element_ID file.\n");
1036                exit(0);
1037        }
1038        hashvalues[1] = hash_data.Hash_value;
1039        while(fscanf(element_ID_in,"%s %d\n",&symbol[0],&index)==2){
1040                int lgth = strlen(symbol);
1041                int hashvalue = compute_hash_value2(symbol,lgth);
1042                cout << symbol <<" "<< lgth<<" "<<hashvalue << endl;
1043                int gid = 0;
1044                switch (lgth)
1045        {
1046                        case 1:
1047                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<1>(symbol, hashvalue);
1048                        break;
1049                        case 2:
1050                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<2>(symbol, hashvalue);
1051                        break;
1052                        case 3:
1053                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<3>(symbol, hashvalue);
1054                        break;
1055                        case 4:
1056                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<4>(symbol, hashvalue);
1057                        break;
1058                        case 5:
1059                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<5>(symbol, hashvalue);
1060                        break;
1061                        case 6:
1062                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<6>(symbol, hashvalue);
1063                        break;
1064                        case 7:
1065                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<7>(symbol, hashvalue);
1066                        break;
1067                        case 8:
1068                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<8>(symbol, hashvalue);
1069                        break;
1070                        case 9:
1071                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<9>(symbol, hashvalue);
1072                        break;
1073                        case 10:
1074                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<10>(symbol, hashvalue);
1075                        break;
1076                        case 11:
1077                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<11>(symbol, hashvalue);
1078                        break;
1079                        case 12:
1080                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<12>(symbol, hashvalue);
1081                        break;
1082                        case 13:
1083                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<13>(symbol, hashvalue);
1084                        break;
1085                        case 14:
1086                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<14>(symbol, hashvalue);
1087                        break;
1088                        case 15:
1089                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<15>(symbol, hashvalue);
1090                        break;
1091                        case 16:
1092                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<16>(symbol, hashvalue);
1093                        break;
1094                        default:
1095                        gid = pbgs_symbol_table.Lookup_or_Insert_Name(symbol, hashvalue, lgth);
1096                        break;         
1097                }
1098                fprintf (gid_writein,"%s |  lgth: %i | hashvalue: %i | gid: %i | symbol: %s\n", __FUNCTION__,  lgth, hashvalue, gid, symbol);
1099        }       
1100        fclose(element_ID_in);
1101//      return;
1102
1103        int buffer_base = 0;
1104        int block_base = 0;
1105        int buffer_pos = 0;
1106        int block_pos = 0;
1107        int errpos = 0;
1108        int chars_avail = 0;
1109        int check_pos = 0;
1110        int chars_read = 0;
1111 
1112        //////////////////////////////////////////////////////////////////////////////////////////
1113    // Buffer Management
1114    //////////////////////////////////////////////////////////////////////////////////////////
1115                //      BitBlock buf[(BUFFER_SIZE)/sizeof(BitBlock)];
1116                //      uint8_t * src_buffer = (uint8_t *)buf + COPYBACK_SIZE;
1117
1118                #ifdef STL_ALIGNED_VECTOR
1119                        std::vector<uint8_t, AAllocator<uint8_t> > src_buffer;
1120                        src_buffer.reserve(BUFFER_SIZE);
1121                #else
1122                        char * COPYBACK;
1123                        char * src_buffer;
1124                        ALLOC_STATIC_ALIGNED_BYTE_BUFFER_WITH_COPYBACK(COPYBACK, src_buffer);
1125                #endif
1126  /*
1127  BytePack buf[(BUFFER_SIZE+BLOCK_SIZE+LOOKAHEAD_SIZE*2)/sizeof(SIMD_type)];
1128
1129  char * srcbuf = ((char *) buf) + LOOKAHEAD_SIZE;
1130  buffer_base = buf_pos;
1131  source = srcbuf;
1132  */
1133  chars_read = fread((void *)&src_buffer[0], 1, SEGMENT_SIZE, infile);
1134  chars_avail = chars_read;
1135  if (chars_avail > BUFFER_SIZE) chars_avail = SEGMENT_SIZE;
1136
1137  if(chars_read<4){
1138    fprintf(stderr,"File is too short. Not well formed.\n");
1139    exit(-1);
1140  }
1141
1142  Entity_Info * e = new Entity_Info;
1143  e->AnalyzeSignature((unsigned char *)&src_buffer[0]);
1144
1145  if (e->code_unit_base == ASCII) {
1146
1147    XML_Decl_Parser<ASCII> decl_parser((unsigned char *)&src_buffer[0]);
1148
1149    decl_parser.ReadXMLInfo(*e);
1150
1151    if (e->code_unit_size != SingleByte || (e->has_encoding_decl && (!at_UTF_8(e->encoding)))){
1152        fprintf(stderr,"Sorry, this xmlwf demo only works for UTF-8.\n");
1153        exit(-1);
1154    }
1155  }
1156  else {
1157    fprintf(stderr,"Sorry, this xmlwf demo does not process EBCDIC.\n");
1158        exit(-1);
1159  }
1160
1161  if (e->content_start != 0) {
1162        memmove(&src_buffer[0], &src_buffer[e->content_start], chars_read - e->content_start);
1163        buffer_pos = e->content_start;
1164//      buffer_base = buffer_pos;
1165        if ((chars_avail-e->content_start) < SEGMENT_SIZE) {
1166                        chars_read = chars_avail - e->content_start + fread(&src_buffer[chars_avail-e->content_start], 1, e->content_start, infile);
1167                        chars_avail = chars_read;
1168                }
1169                if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
1170  }
1171
1172        //////////////////////////////////////////////////////////////////////////////////////////
1173        // Read OVERLAP bytes to support post processing validation lookahead.
1174        //////////////////////////////////////////////////////////////////////////////////////////
1175        chars_read = chars_avail + fread(&src_buffer[chars_avail], 1, LOOKAHEAD_SIZE, infile);
1176        chars_avail = chars_read;
1177        if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
1178
1179@stream_stmts
1180
1181        #ifndef STL_ALIGNED_VECTOR
1182        matcher.setSrc((char *)&src_buffer[0]);
1183        #endif
1184
1185/* Full Buffers */
1186    int block_segment_num = 0;
1187    while (chars_avail >= SEGMENT_SIZE) {
1188      PERF_SEC_START(parser_timer);
1189      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
1190        cout << "loops" << ends;
1191                block_base = blk*BLOCK_SIZE;
1192        s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
1193     
1194                @block_stmts
1195         
1196                tracker.StoreNewlines(lex.LF);
1197                cout << "post start" << endl;
1198//              postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
1199                postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
1200                vectoring(tag_Callouts,hash_data,(char *)&src_buffer[0],block_base);
1201                cout << "post done" << endl;
1202                #ifndef STL_ALIGNED_VECTOR
1203                matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
1204                #endif
1205                tracker.AdvanceBlock();
1206                cout << "loop" << endl;
1207      }
1208      #ifndef STL_ALIGNED_VECTOR
1209      matcher.StreamScan(chars_avail);
1210      matcher.Advance_buffer();
1211      #endif
1212      cout << "11111" << endl;
1213      PERF_SEC_END(parser_timer, chars_avail);
1214          cout << "here" << endl;
1215      int bytes_left = chars_read - chars_avail;
1216      //////////////////
1217      //element name buffer, for scanning element name backwards
1218      /////////////////
1219      memmove(&element_name_buffer[0],&src_buffer[SEGMENT_SIZE-ELEMENT_BUFFER_SIZE],ELEMENT_BUFFER_SIZE);
1220      cross_buffer_flag = 1;
1221     
1222      memmove(&src_buffer[0], &src_buffer[SEGMENT_SIZE], LOOKAHEAD_SIZE);
1223      chars_read = fread(&src_buffer[LOOKAHEAD_SIZE],1,SEGMENT_SIZE, infile) + LOOKAHEAD_SIZE;
1224      chars_avail = chars_read;
1225      cout << "here" << endl;
1226      if (chars_avail > SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
1227      buffer_pos += chars_avail;
1228      buffer_base = buffer_pos;
1229      block_segment_num++;
1230
1231  }
1232       
1233/* Final Partial Buffer */
1234    PERF_SEC_START(parser_timer);
1235
1236    block_pos = 0;
1237    int remaining = chars_avail;
1238
1239
1240
1241/* Full Blocks */
1242    while (remaining >= BLOCK_SIZE) {
1243          block_base = block_pos;
1244          s2p_do_block((BytePack *) &src_buffer[block_pos], basis_bits);
1245         
1246          @block_stmts
1247         
1248          tracker.StoreNewlines(lex.LF);
1249          cout << "post start1" << endl;
1250         
1251//        postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
1252          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
1253          vectoring(tag_Callouts,hash_data,(char *)&src_buffer[0],block_base);
1254          cout << "post end2" << endl;
1255          #ifndef STL_ALIGNED_VECTOR
1256          matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
1257          #endif
1258          tracker.AdvanceBlock();
1259          block_pos += BLOCK_SIZE;
1260          remaining -= BLOCK_SIZE;
1261    }
1262    block_base = block_pos;
1263        #ifdef USE_ANY_CARRY_TEST
1264    if (remaining > 0 || @any_carry) {
1265        #endif
1266          EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
1267          s2p_do_final_block((BytePack *) &src_buffer[block_pos], basis_bits, EOF_mask);
1268          @final_block_stmts
1269          cout << "post start3" << endl;
1270//        postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
1271          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
1272          vectoring(tag_Callouts,hash_data,(char *)&src_buffer[0],block_base);
1273          cout << "post end3" << endl;
1274          #ifndef STL_ALIGNED_VECTOR
1275      matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
1276          #endif
1277          tracker.AdvanceBlock();
1278        #ifdef USE_ANY_CARRY_TEST
1279    }
1280    #endif
1281    buffer_pos += chars_avail;
1282    buffer_base = buffer_pos;
1283        #ifndef STL_ALIGNED_VECTOR
1284    matcher.StreamScan(chars_avail);
1285    matcher.Advance_buffer();
1286//    tracker.Advance_buffer();
1287
1288   
1289    if (matcher.depth != 0) {
1290      fprintf(stderr, "tag matching error (depth %i) at position %i\n", matcher.depth, buffer_base);
1291      exit(-1);
1292     
1293     
1294    }
1295    #endif
1296    PERF_SEC_END(parser_timer, chars_avail);
1297//  print_GIDS();
1298//    pbgs_symbol_table.Print_Symbol_Table_Distribution();
1299}
1300
1301
1302
1303int
1304main(int argc, char * argv[]) {
1305        char * infilename, * outfilename;
1306        FILE *infile, *outfile;
1307        struct stat fileinfo;
1308
1309        if (argc < 2) {
1310                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
1311                exit(-1);
1312        }
1313
1314        infilename = argv[1];
1315        stat(infilename, &fileinfo);
1316        infile = fopen(infilename, "rb");
1317        if (!infile) {
1318                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
1319                exit(-1);
1320        }
1321
1322        if (argc < 3) outfile = stdout;
1323        else {
1324                outfilename = argv[2];
1325                outfile = fopen(outfilename, "wb");
1326                if (!outfile) {
1327                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
1328                        exit(-1);
1329                }
1330        }
1331
1332//      PERF_SEC_BIND(1);
1333
1334        PERF_SEC_INIT(parser_timer);
1335
1336        do_process(infile, outfile);
1337       
1338#if DEBUG
1339print_gid_vec();
1340#endif
1341        //cout << "validate start" << endl;
1342        validate();
1343
1344        PERF_SEC_DUMP(parser_timer);
1345
1346        PERF_SEC_DESTROY(parser_timer);
1347
1348        fclose(infile);
1349        fclose(outfile);
1350
1351        printf ("Done procressing\n");
1352        return(0);
1353}
Note: See TracBrowser for help on using the repository browser.