source: proto/xmlschema/temp.cpp @ 2317

Last change on this file since 2317 was 2219, checked in by shiyangy, 7 years ago

project checkin

File size: 30.2 KB
Line 
1#define VECTOR_WIDTH 8
2#define VECTOR_TYPE (char)
3
4#include <stdio.h>
5#include <stdlib.h>
6#include <errno.h>
7#include <sys/types.h>
8#include <sys/stat.h>
9
10#define LocalCarryDeclare(name, count)\
11CarryArray<count> name;\
12
13#include "../lib/carryQ.hpp"
14#include "../lib/bitstream_iterator.hpp"
15#include "../lib/bitblock_iterator.hpp"
16
17#define SEGMENT_BLOCKS 12
18#define BUFFER_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
19#define OVERLAP_BUFSIZE (sizeof(BitBlock))
20
21#include "xmldecl.h"
22#include "namechars.h"
23#include "../lib/perflib/perfsec.h"
24#include "../lib/s2p.hpp"
25
26#include "TagMatcher.hpp"
27#include "LineColTracker.hpp"
28#include "ErrorUtil.h"
29#include "ErrorTracker.h"
30#include "XMLTestSuiteError.h"h"
31a
32#ifdef BUFFER_PROFILING
33        BOM_Table * parser_timer;
34
35#elif CODE_CLOCKER
36        #define NUM_EVENTS 1
37        int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
38        //int Events[NUM_EVENTS] = {PAPI_L2_DCM};
39        //int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
40        int cal_size = 20;
41        CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
42#else
43        void * parser_timer;
44#endif
45
46int block_base=0;
47int buffer_base=0;
48int buffer_last;
49char * source;
50LineColTracker tracker;
51
52static inline void ReportError(const char * error_msg, int error_pos_in_block) {
53  int error_line, error_column;
54  tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
55  fprintf(stderr, "%s at line %i, column %i\n", error_msg, error_line, error_column);
56}
57
58class ErrorTracker {
59public:
60    ErrorTracker() { noted_pos_in_block = -1;}
61
62    inline void NoteError(const char * error_msg, BitBlock err_strm) {
63      int pos_in_block = count_forward_zeroes(err_strm);
64      if ((noted_pos_in_block == -1) || (noted_pos_in_block > pos_in_block)) {
65        noted_pos_in_block = pos_in_block;
66        noted_error = error_msg;
67      }
68    }
69
70    inline void If_Error_Report_First() {
71      if (noted_pos_in_block > -1) {
72              int error_line, error_column;
73              ReportError(noted_error, noted_pos_in_block);
74              exit(-1);
75      }
76    }
77
78private:
79  const char * noted_error;
80  int noted_pos_in_block;
81};
82
83
84TagMatcher matcher;
85BitBlock EOF_mask = simd_const_1(1);
86
87ErrorTracker error_tracker;
88BitBlock elem_starts;
89int previous_block_last_elem_start;
90BytePack hashvalues[2];
91
92vector <int> gids;
93PBGSIdentitySymbolTable pbgs_symbol_table;
94
95stack <vector<char>* > elem_vec_stack;
96map<char, vector<char>* > elem_vec_map;
97map<char, vector<int>* > elem_pos_map;
98
99FILE * ofile;
100
101static inline int ScanBackwardPos(BitBlock * block, int pos)
102{
103    BitBlock s = block[0];
104    BitBlock temp = simd_and( s, simd_not(simd<128>::sll(simd<1>::constant<1>(), sisd_from_int(pos))) );
105
106    if (bitblock_has_bit(temp))
107    {
108        // sizeof (BitBlock)*8 - cbzl( s & ~(~0 << pos)) - 1;
109        return BLOCK_SIZE - count_backward_zeroes (temp) - 1;
110    }
111    else
112    {
113        //handle boundary case
114        return previous_block_last_elem_start - 1;
115    }
116}
117
118static inline int StreamScan(ScanBlock * stream, int blk_count, int ProcessPos(int)) {
119        int blk;
120        int block_pos = 0;
121        for (blk = 0; blk < blk_count; blk++) {
122                ScanBlock s = stream[blk];
123                while(s) {
124                        int code = (ProcessPos(cfzl(s) + block_pos));
125                        if (code) return code;
126                        s = s & (s-1);  // clear rightmost bit.
127                }
128                block_pos += 8 * sizeof(ScanBlock);
129        }
130        return 0;
131}
132
133static inline int compute_hash_value (int lgth, int start)
134{
135    unsigned int offset_bit = start + 128;
136    uint64_t stream = *((uint64_t*)(((uint32_t*)hashvalues)+(offset_bit>>5)));
137    return stream >> (offset_bit & 0x1F) & ~(~0 << lgth);
138}
139/*
140template <int L>
141static inline int ElemEnd_grouping(int pos) {
142    int end = block_base + pos;
143    int start = end - L;
144    int hashvalue = compute_hash_value(L, start - block_base);
145    int gid = pbgs_symbol_table.Lookup_or_Insert_Name<L>(source + start, hashvalue);
146    gids.push_back(gid);
147#if DEBUG
148    char* symbol = new char[L+1];
149    strncpy ( symbol, source + start, L );
150    symbol[L] ='\0';
151    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 );
152    delete symbol; symbol = 0;
153#endif
154    return gid;
155}
156
157template<>
158inline int ElemEnd_grouping<17>(int pos) {
159    int end = block_base + pos;
160    int start = ScanBackwardPos (&elem_starts, pos) + block_base;
161    int lgth = end - start;
162    int hashvalue = compute_hash_value(lgth, start - block_base);
163    int gid = 0;
164
165//    if (lgth < 32)
166//    {
167//      gid = pbgs_symbol_table.Lookup_or_Insert_Name_32(source + start, hashvalue, lgth);
168//    }
169//    else
170    {
171        gid = pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
172    }
173    gids.push_back(gid);
174#if DEBUG
175    char* symbol = new char[lgth+1];
176    strncpy ( symbol, source + start, lgth );
177    symbol[lgth] ='\0';
178    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);
179#endif
180    return gid;
181}
182*/
183
184inline char ElemEnd_grouping(int pos) {
185    int end = block_base + pos;
186    int start = ScanBackwardPos (&elem_starts, pos) + block_base;
187    int lgth = end - start;
188    int hashvalue = compute_hash_value(lgth, start - block_base);
189    char gid = 0;
190
191//    if (lgth < 32)
192//    {
193//      gid = pbgs_symbol_table.Lookup_or_Insert_Name_32(source + start, hashvalue, lgth);
194//    }
195//    else
196
197        switch (lgth)
198    {
199    case 1:
200        gid = pbgs_symbol_table.Lookup_or_Insert_Name<1>(source + start, hashvalue);
201        break;
202    case 2:
203        gid = pbgs_symbol_table.Lookup_or_Insert_Name<2>(source + start, hashvalue);
204        break;
205    case 3:
206        gid = pbgs_symbol_table.Lookup_or_Insert_Name<3>(source + start, hashvalue);
207        break;
208    case 4:
209        gid = pbgs_symbol_table.Lookup_or_Insert_Name<4>(source + start, hashvalue);
210        break;
211    case 5:
212        gid = pbgs_symbol_table.Lookup_or_Insert_Name<5>(source + start, hashvalue);
213        break;
214    case 6:
215        gid = pbgs_symbol_table.Lookup_or_Insert_Name<6>(source + start, hashvalue);
216        break;
217    case 7:
218        gid = pbgs_symbol_table.Lookup_or_Insert_Name<7>(source + start, hashvalue);
219        break;
220    case 8:
221        gid = pbgs_symbol_table.Lookup_or_Insert_Name<8>(source + start, hashvalue);
222        break;
223    case 9:
224        gid = pbgs_symbol_table.Lookup_or_Insert_Name<9>(source + start, hashvalue);
225        break;
226    case 10:
227        gid = pbgs_symbol_table.Lookup_or_Insert_Name<10>(source + start, hashvalue);
228        break;
229    case 11:
230        gid = pbgs_symbol_table.Lookup_or_Insert_Name<11>(source + start, hashvalue);
231        break;
232    case 12:
233        gid = pbgs_symbol_table.Lookup_or_Insert_Name<12>(source + start, hashvalue);
234        break;
235    case 13:
236        gid = pbgs_symbol_table.Lookup_or_Insert_Name<13>(source + start, hashvalue);
237        break;
238    case 14:
239        gid = pbgs_symbol_table.Lookup_or_Insert_Name<14>(source + start, hashvalue);
240        break;
241    case 15:
242        gid = pbgs_symbol_table.Lookup_or_Insert_Name<15>(source + start, hashvalue);
243        break;
244    case 16:
245        gid = pbgs_symbol_table.Lookup_or_Insert_Name<16>(source + start, hashvalue);
246        break;
247    default:
248        gid = pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
249        break;
250    }
251/*
252    {
253        gid = (char)pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
254    }
255*/
256    gids.push_back(gid);
257#if DEBUG
258    char* symbol = new char[lgth+1];
259    strncpy ( symbol, source + start, lgth );
260    symbol[lgth] ='\0';
261    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);
262#endif
263        char* symbol = new char[lgth+1];
264    strncpy ( symbol, source + start, lgth );
265    symbol[lgth] ='\0';
266        fprintf(ofile,"%i\t%s\n",gid,symbol); 
267    return gid;
268}
269
270//template <int L>
271static inline int StreamScanLengthGrouping(ScanBlock * stream, ScanBlock * stream2, int blk_count) {
272    int blk;
273    int block_pos = 0;
274    for (blk = 0; blk < blk_count; blk++) {
275        ScanBlock s = stream[blk];
276        ScanBlock s2 = stream2[blk];
277        while(s | s2) {
278//              cout << "end_pos:"<<s<<endl;
279//              cout << "end_tag_marks:"<<s2<<endl;
280            int end_pos = cfzl(s) + block_pos;
281            int end_tag = cfzl(s2) + block_pos;
282//          cout << "cfzl(s):" << cfzl(s)<<endl;
283//          cout << "cfzl(s2):" << cfzl(s2)<<endl;
284//              cout << (end_tag < end_pos && s2 != 0)<< "||" <<(s == 0 && s2 != 0)  << endl;
285            if ((end_tag < end_pos && s2 != 0) | (s == 0 && s2 != 0)){
286//          cout << "closing tag" << endl;
287//              cout << "endtag:" << end_tag << " " << end_pos<<endl;
288//              cout << "1"<< endl;
289//              cout << elem_vec_stack.size()<<endl;
290//              cout << "2" << endl;
291//              cout << elem_vec_stack.top()<<endl;
292                if (!(*elem_vec_stack.top()).empty()){
293                        if ((*elem_vec_stack.top()).back() != 0 ){
294                                (*elem_vec_stack.top()).push_back(0);   
295                        }
296                }
297                elem_vec_stack.pop();
298//              cout<<"poped\n";
299                s2 = s2 & (s2 - 1);
300            }else{
301//              cout << " end_pos == " << end_pos<<endl;
302                char gid = ElemEnd_grouping(end_pos);
303                s = s & (s-1);  // clear rightmost bit.
304                if (gid != 0){
305//                      cout << "gid " << gid<< endl;
306                        if(elem_vec_map.find(gid) != elem_vec_map.end()){
307//                              cout << "found vector" << gid << endl;
308                                (*elem_vec_stack.top()).push_back(gid);
309//                              cout << "top vector size: " << (*elem_vec_map[gid]).size() << endl;
310                                elem_vec_stack.push(elem_vec_map[gid]);
311//                              cout << "pushed in" << endl;
312//                              cout << "found " << gid << endl;
313                        }else{
314//                              cout << "size :" << elem_vec_stack.size()<<endl;
315//                              cout << endl;
316//                              cout << elem_vec_stack.top()<<endl;
317                               
318//                              cout << "size before " <<(*elem_vec_stack.top()).size() << endl;
319                                (*elem_vec_stack.top()).push_back(gid); 
320//                              cout << "size after " <<(*elem_vec_stack.top()).size() << endl;
321                               
322                                vector<char> *tmp = new vector<char>;
323                                elem_vec_map[gid] = tmp;
324                                elem_vec_stack.push(tmp);
325//                              cout << "size after :" << elem_vec_stack.size()<<endl;
326                        }
327                }
328
329            }
330        }
331        block_pos += 8 * sizeof(ScanBlock);
332    }
333    return 0;
334}
335
336void print_vecs(){
337        int i = 1;
338        int lst[256] = {0};
339        cout << elem_vec_map.size() << " vectors" << endl; 
340        for (int i = 0;i < gids.size(); i++){
341                if (lst[gids[i]] == 0){
342                        cout << "gid: " << gids[i] << endl;
343                        lst[gids[i]] = 1;
344                        vector<char> *tmp = elem_vec_map[gids[i]];
345                        cout << "vector size:"<< (*tmp).size()<<endl;
346                        if ((*tmp).size()!=0){
347                                cout << "elements: ";
348                                for (int j = 0; j < (*tmp).size();j++){
349                                        cout << (int)(*tmp)[j] << " ";
350                                }
351                                cout << endl;
352                        }
353                        cout << endl;
354                }
355        }
356/*
357        for(int i = 0;i < gids.size();i++){
358                cout << " i : " << i << endl;
359                vector<short int> *tmp = elem_vec_map[gids[i]];
360                cout << "found" << endl;
361                cout << "map size:" << elem_vec_map.size()<< endl;
362                for (map<short int, vector<short int>* >::iterator pos = elem_vec_map.begin(); pos != elem_vec_map.end(); pos++){
363                        cout << "vector size" << (pos->second)->size() << endl;
364                }
365                cout << "size:" << tmp->size()<< endl;
366               
367                for (int j = 0;j < tmp->size();j++){
368                        cout <<tmp[j]<<" ";
369                }
370
371        }
372*/
373}
374
375static inline int NameStrt_check(int pos) {
376        int block_pos = block_base + pos;
377        if(XML_10_UTF8_NameStrt_bytes((unsigned char*)&source[block_pos]) == 0){
378              ReportError("name start error", pos);
379              exit(-1);
380        }
381        return 0;
382}
383
384static inline int Name_check(int pos) {
385        int block_pos = block_base + pos;
386        if(XML_10_UTF8_NameChar_bytes((unsigned char*)&source[block_pos]) == 0){
387              ReportError("name error", pos);
388              exit(-1);
389        }
390        return 0;
391}
392
393static inline int PIName_check(int pos) {
394        int block_pos = block_base + pos;
395        int file_pos = block_pos+buffer_base;
396        printf ("%s:%i\n",__FUNCTION__,pos);
397        if (at_XxMmLll<ASCII>((unsigned char*)&source[block_pos]) && (source[block_pos+3]=='?' || source[block_pos+3]<= ' ')) {
398              // "<?xml" legal at start of file.
399              if ((file_pos == 2) && at_XmlDecl_start<ASCII>((unsigned char*)&source[0])) return 0;
400              ReportError("[Xx][Mm][Ll] illegal as PI name", pos);
401              exit(-1);
402        }
403        return 0;
404}
405
406static inline int CD_check(int pos) {
407        int block_pos = block_base + pos;
408        if (!at_CDATA1<ASCII>((unsigned char*)&source[block_pos])){
409              ReportError("CDATA error", pos);
410              exit(-1);
411        }
412        return 0;
413}
414
415static inline int GenRef_check(int pos) {
416        int block_pos = block_base + pos;
417        unsigned char* s = (unsigned char*)&source[block_pos];
418        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))){
419              ReportError("Undefined reference", pos);
420              exit(-1);
421        }
422        return 0;
423}
424
425static inline int HexRef_check(int pos) {
426        int block_pos = block_base + pos;
427        unsigned char* s = (unsigned char*)&source[block_pos];
428        int ch_val = 0;
429        while(at_HexDigit<ASCII>(s)){
430          ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
431          if (ch_val> 0x10FFFF ){
432            ReportError("Illegal character reference", pos);
433            exit(-1);
434          }
435          s++;
436        }
437        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
438          ReportError("Illegal character reference", pos);
439          exit(-1);
440        }
441        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
442          ReportError("Illegal XML 1.0 character reference", pos);
443          exit(-1);
444        }
445        return 0;
446}
447
448static inline int DecRef_check(int pos) {
449        int block_pos = block_base + pos;
450        unsigned char* s = (unsigned char*)&source[block_pos];
451        int ch_val = 0;
452        while(at_HexDigit<ASCII>(s)){
453          ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
454          if (ch_val> 0x10FFFF ){
455            ReportError("Illegal character reference", pos);
456            exit(-1);
457          }
458          s++;
459        }
460        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
461          ReportError("Illegal character reference", pos);
462          exit(-1);
463        }
464        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
465          ReportError("Illegal XML 1.0 character reference", pos);
466          exit(-1);
467        }
468        return 0;
469}
470
471static inline int AttRef_check(int pos) {
472        int block_pos = block_base + pos;
473        unsigned char* s = (unsigned char*)&source[block_pos];
474        int ch_val = 0;
475        if(s[0]=='#'){
476          s++;
477          if(s[0]=='x' || s[0]=='X'){
478            s++;
479            while(at_HexDigit<ASCII>(s)){
480              ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
481              s++;
482            }
483          }
484          else{
485            while(at_HexDigit<ASCII>(s)){
486              ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
487              s++;
488            }
489          }
490          if (ch_val==60){
491            ReportError("Attribute values contain '<' characters after reference expansion", pos);
492            exit(-1);
493          }
494        }
495        else if(at_Ref_lt<ASCII>(s)){
496          ReportError("Attribute values contain '<' characters after reference expansion", pos);
497          exit(-1);
498        }
499        return 0;
500}
501
502
503
504@global
505
506
507
508static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
509  s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
510        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);
511}
512
513static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask) {
514  s2p_do_block(U8, basis_bits);
515  basis_bits.bit_0 = simd_and(basis_bits.bit_0, EOF_mask);
516  basis_bits.bit_1 = simd_and(basis_bits.bit_1, EOF_mask);
517  basis_bits.bit_2 = simd_and(basis_bits.bit_2, EOF_mask);
518  basis_bits.bit_3 = simd_and(basis_bits.bit_3, EOF_mask);
519  basis_bits.bit_4 = simd_and(basis_bits.bit_4, EOF_mask);
520  basis_bits.bit_5 = simd_and(basis_bits.bit_5, EOF_mask);
521  basis_bits.bit_6 = simd_and(basis_bits.bit_6, EOF_mask);
522  basis_bits.bit_7 = simd_and(basis_bits.bit_7, EOF_mask);
523}
524
525static inline void print_basis_bits(Basis_bits & basis_bits){
526        print_bit_block("bit0:",basis_bits.bit_0);
527        print_bit_block("bit1:",basis_bits.bit_1);
528        print_bit_block("bit2:",basis_bits.bit_2);
529        print_bit_block("bit3:",basis_bits.bit_3);
530        print_bit_block("bit4:",basis_bits.bit_4);
531        print_bit_block("bit5:",basis_bits.bit_5);
532        print_bit_block("bit6:",basis_bits.bit_6);
533        print_bit_block("bit7:",basis_bits.bit_7);                                     
534}
535
536static inline void print_elem_vec(vector<char>* vec, int size){
537        cout << "vector: ";
538        for (int i = 0; i<size ; i++){
539                cout << (int)(*vec)[i] <<" ";
540        }
541        cout << endl;
542}
543
544/*
545static inline void validate_vec_11(){
546        Validate_Vec_11 validate_Vec_11;
547        Elem elem;
548        vector<char>* vector_11 = elem_vec_map[11];
549        cout << "vector_11 size " << (*vector_11).size() << endl;
550        int lgth = (*vector_11).size();
551        int remaining = 0;
552        Basis_bits basis_bits;
553        if (lgth != 0){
554                int i = 0;
555                int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
556                remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
557                for (i = 0;i < num_block; i++){
558//                      s2p_do_block((BytePack*)(vector_11[i]),temp_basis_bits);
559                        s2p_do_block(((BytePack*)(&(*vector_11)[i])), basis_bits);
560                        validate_Vec_11.do_block(elem, basis_bits);
561                        print_elem_vec(vector_11,lgth);
562                        print_basis_bits(basis_bits);
563                        print_vec_11(elem);
564//                      (BytePack*)(iter->second)
565                        cout << i ;
566                }
567                cout << endl;
568                if (remaining !=0){
569                        BitBlock EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-remaining));
570                        s2p_do_final_block(((BytePack*)(&(*vector_11)[i])), basis_bits,EOF_mask);
571                        validate_Vec_11.do_final_block(elem,basis_bits,EOF_mask);
572                        print_elem_vec((vector_11)+i,lgth);
573                        print_basis_bits(basis_bits);
574                        print_vec_11(elem);
575                }
576        }
577//      print_bit_block("error",error);
578        cout << "validation vec_11 done" << endl;
579}
580*/
581
582static inline void validate_vec_3(){
583
584}
585
586
587static inline void validate_vecs(){
588        int lgth = (*elem_vec_map[3]).size();
589        print_elem_vec(elem_vec_map[3],lgth);
590//      validate_vec_11();
591/*
592        vector<int> test;
593        for(int i = 1;i <12; i++){
594                test.push_back(i);
595        }
596//      int test[] = {1,2,3,4,5,6,7,8,9,10,11};
597        Basis_bits temp_basis_bits;
598        BitBlock EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-44));
599        s2p_do_final_block((BytePack*)(&(test[0])), temp_basis_bits,EOF_mask);
600        print_basis_bits(temp_basis_bits);
601*/
602/*
603        for (map<char, vector<char>* > ::const_iterator iter = elem_vec_map.begin(); iter!= elem_vec_map.end(); ++iter){
604                int i = 0;
605                int lgth = (*(iter->second)).size();
606                int remaining;
607                if (lgth != 0){
608                        cout <<"vector key "<< (int)iter->first << endl;
609//                      cout <<"vector ptr" << iter->second<<endl;
610               
611                        cout <<"vector size: " << lgth << endl;
612                        int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
613                        remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
614                        for (i = 0;i < num_block; i++){
615                                Basis_bits temp_basis_bits;
616                                s2p_do_block(((BytePack*)(&(*(iter->second))[i])), temp_basis_bits);
617                                print_elem_vec(iter->second,lgth);
618                                print_basis_bits(temp_basis_bits);
619//                              (BytePack*)(iter->second)
620                                cout << i ;
621                        }
622                        cout << endl;
623                        if (remaining !=0){
624                                BitBlock EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-remaining));
625                                Basis_bits temp_basis_bits;
626                                s2p_do_final_block(((BytePack*)(&(*(iter->second))[i])), temp_basis_bits,EOF_mask);
627                                print_elem_vec((iter->second)+i,lgth);
628                                print_basis_bits(temp_basis_bits);
629                        }
630                }                       
631        }
632*/
633}
634/*
635static inline void validation_do_block(Lex & lex, Tag_Callouts & tag_Callouts, Hash_data & hash_data, int chars_avail){
636        elem_starts = tag_Callouts.ElemName_starts_no_ns;
637    hashvalues[1] = hash_data.Hash_value;
638
639        StreamScanLengthGrouping((ScanBlock *) &tag_Callouts.ElemName_ends,(ScanBlock *) &tag_Callouts.Tag_closing, sizeof(BitBlock)/sizeof(ScanBlock));
640}
641*/
642
643static 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){
644
645
646    //NOTE: We are NOT handling the case for an extremely long symbol name (length > 1541).
647    //      TagMatcher will crash if we feed a long symbol name.
648    //      Sample file: test/long_sym_name.xml
649
650    tracker.StoreNewlines(lex.LF);
651       
652/*
653    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_1) )
654    {
655        StreamScanLengthGrouping<1>((ScanBlock *) &tag_Callouts.ElemName_ends_1,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
656    }
657
658    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_2) )
659    {
660        StreamScanLengthGrouping<2>((ScanBlock *) &tag_Callouts.ElemName_ends_2,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
661    }
662
663    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_3) )
664    {
665        StreamScanLengthGrouping<3>((ScanBlock *) &tag_Callouts.ElemName_ends_3,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
666    }
667
668    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_4) )
669    {
670        StreamScanLengthGrouping<4>((ScanBlock *) &tag_Callouts.ElemName_ends_4,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
671    }
672
673    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_5) )
674    {
675        StreamScanLengthGrouping<5>((ScanBlock *) &tag_Callouts.ElemName_ends_5,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
676    }
677
678    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_6) )
679    {
680        StreamScanLengthGrouping<6>((ScanBlock *) &tag_Callouts.ElemName_ends_6,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
681    }
682
683    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_7) )
684    {
685        StreamScanLengthGrouping<7>((ScanBlock *) &tag_Callouts.ElemName_ends_7,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
686    }
687
688    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_8) )
689    {
690        StreamScanLengthGrouping<8>((ScanBlock *) &tag_Callouts.ElemName_ends_8,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
691    }
692
693    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_9) )
694    {
695        StreamScanLengthGrouping<9>((ScanBlock *) &tag_Callouts.ElemName_ends_9,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
696    }
697
698    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_10) )
699    {
700        StreamScanLengthGrouping<10>((ScanBlock *) &tag_Callouts.ElemName_ends_10,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
701    }
702
703    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_11) )
704    {
705        StreamScanLengthGrouping<11>((ScanBlock *) &tag_Callouts.ElemName_ends_11,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
706    }
707
708    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_12) )
709    {
710        StreamScanLengthGrouping<12>((ScanBlock *) &tag_Callouts.ElemName_ends_12,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
711    }
712
713    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_13) )
714    {
715        StreamScanLengthGrouping<13>((ScanBlock *) &tag_Callouts.ElemName_ends_13,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
716    }
717
718    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_14) )
719    {
720        StreamScanLengthGrouping<14>((ScanBlock *) &tag_Callouts.ElemName_ends_14,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
721    }
722
723    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_15) )
724    {
725        StreamScanLengthGrouping<15>((ScanBlock *) &tag_Callouts.ElemName_ends_15,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
726    }
727
728    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_16) )
729    {
730        StreamScanLengthGrouping<16>((ScanBlock *) &tag_Callouts.ElemName_ends_16,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
731    }
732
733    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_17_and_longer) )
734    {
735        StreamScanLengthGrouping<17>((ScanBlock *) &tag_Callouts.ElemName_ends_17_and_longer,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
736    }
737
738*/
739
740
741
742    // Store the last starting position in case we hit boundary case
743    previous_block_last_elem_start = - count_backward_zeroes (elem_starts);
744
745    //copy current hash value data as previous one.
746    memmove (&hashvalues[0], &hashvalues[1], 16);
747
748    if (bitblock_has_bit(simd_or(check_streams.non_ascii_name_starts, check_streams.non_ascii_names))) {
749      StreamScan((ScanBlock *) &check_streams.non_ascii_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), NameStrt_check);
750      StreamScan((ScanBlock *) &check_streams.non_ascii_names, sizeof(BitBlock)/sizeof(ScanBlock), Name_check);
751    }
752
753    if (bitblock_has_bit(ctCDPI_Callouts.PI_name_starts)){
754      StreamScan((ScanBlock *) &ctCDPI_Callouts.PI_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), PIName_check);
755    }
756
757    if (bitblock_has_bit(ctCDPI_Callouts.CD_starts)){
758      StreamScan((ScanBlock *) &ctCDPI_Callouts.CD_starts, sizeof(BitBlock)/sizeof(ScanBlock), CD_check);
759    }
760
761    if (bitblock_has_bit(ref_Callouts.GenRef_starts)){
762      StreamScan((ScanBlock *) &ref_Callouts.GenRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), GenRef_check);
763    }
764
765    if (bitblock_has_bit(ref_Callouts.DecRef_starts)){
766      StreamScan((ScanBlock *) &ref_Callouts.DecRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), DecRef_check);
767    }
768
769    if (bitblock_has_bit(ref_Callouts.HexRef_starts)){
770      StreamScan((ScanBlock *) &ref_Callouts.HexRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), HexRef_check);
771    }
772
773    if (bitblock_has_bit(check_streams.att_refs)){
774      StreamScan((ScanBlock *) &check_streams.att_refs, sizeof(BitBlock)/sizeof(ScanBlock), AttRef_check);
775    }
776
777    error_tracker.If_Error_Report_First();
778
779    matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
780    tracker.AdvanceBlock();
781}
782
783static inline void print_GIDS()
784{
785    int span_count = gids.size();
786    for(int i=0;i<span_count;i++) {
787             cout << gids[i] << " ";
788    }
789    cout << endl;
790}
791
792static inline int test(int)
793{
794    return 0;
795}
796
797void do_process(FILE *infile, FILE *outfile) {
798
799@decl
800  int buf_pos = 0;
801  int block_pos = 0;
802  int errpos = 0;
803  int chars_avail = 0;
804  int check_pos = 0;
805  int chars_read = 0;
806  BytePack buf[(BUFFER_SIZE+BLOCK_SIZE+OVERLAP_BUFSIZE*2)/sizeof(SIMD_type)];
807BytePack temp_buf[(BUFFER_SIZE+BLOCK_SIZE+OVERLAP_BUFSIZE*2)/sizeof(SIMD_type)];
808char * contentbuf = ((char *) temp_buf) + OVERLAP_BUFSIZE;
809int contbuf_pos = 0;
810  char * srcbuf = ((char *) buf) + OVERLAP_BUFSIZE;
811  buffer_base = buf_pos;
812  source = srcbuf;
813  chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE + OVERLAP_BUFSIZE, infile);
814  chars_avail = chars_read;
815  if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
816
817  matcher.setSrc(srcbuf);
818
819  if(chars_read<4){
820    fprintf(stderr,"File is too short. Not well formed.\n");
821    exit(-1);
822  }
823
824  Entity_Info * e = new Entity_Info;
825  e->AnalyzeSignature((unsigned char *)srcbuf);
826
827  if (e->code_unit_base == ASCII) {
828
829    XML_Decl_Parser<ASCII> decl_parser((unsigned char *)srcbuf);
830
831    decl_parser.ReadXMLInfo(*e);
832
833    if (e->code_unit_size != SingleByte || (e->has_encoding_decl && (!at_UTF_8(e->encoding)))){
834        fprintf(stderr,"Sorry, this xmlwf demo only works for UTF-8.\n");
835        exit(-1);
836    }
837  }
838  else {
839    fprintf(stderr,"Sorry, this xmlwf demo does not process EBCDIC.\n");
840        exit(-1);
841  }
842
843  if (e->content_start != 0) {
844        memmove(&srcbuf[0], &srcbuf[e->content_start], chars_read - e->content_start);
845        buf_pos = e->content_start;
846        buffer_base = buf_pos;
847        if (chars_avail == BUFFER_SIZE) {
848                chars_read = chars_read - e->content_start +
849                             fread(&srcbuf[chars_read-e->content_start], 1, e->content_start, infile);
850                chars_avail = chars_read;
851                if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
852        }
853        else {
854          chars_read -=e->content_start;
855          chars_avail -=e->content_start;
856        }
857  }
858
859@stream_stmts
860
861        vector<char> *root = new vector<char>;
862        elem_vec_stack.push(root);
863        cout<<"root_size "<<elem_vec_stack.size()<<endl;
864       
865        elem_vec_map[0] = root;
866
867/* Full Buffers */
868    int block_segment_num = 0;
869    while (chars_avail == BUFFER_SIZE) {
870      PERF_SEC_START(parser_timer);
871      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
872          block_base = blk*BLOCK_SIZE;
873          s2p_do_block((BytePack *) &srcbuf[block_base], basis_bits);
874          @block_stmts
875          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
876          validation_do_block(lex, tag_Callouts, hash_data, chars_avail);
877      }
878      matcher.StreamScan(chars_avail);
879      matcher.Advance_buffer();
880      tracker.Advance_buffer();
881      PERF_SEC_END(parser_timer, chars_avail);
882
883      int bytes_left = chars_read - chars_avail;
884      memmove(buf, &srcbuf[BUFFER_SIZE - OVERLAP_BUFSIZE], bytes_left + OVERLAP_BUFSIZE);
885      chars_read = fread(&srcbuf[bytes_left],1, BUFFER_SIZE + OVERLAP_BUFSIZE - bytes_left, infile) + bytes_left;
886
887      chars_avail = chars_read;
888      if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
889      buf_pos += chars_avail;
890      buffer_base = buf_pos;
891      block_segment_num++;
892
893  }
894 
895       
896/* Final Partial Buffer */
897    PERF_SEC_START(parser_timer);
898
899    block_pos = 0;
900    int remaining = chars_avail;
901
902
903
904/* Full Blocks */
905    while (remaining >= BLOCK_SIZE) {
906          block_base = block_pos;
907          s2p_do_block((BytePack *) &srcbuf[block_pos], basis_bits);
908          @block_stmts
909          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
910          validation_do_block(lex, tag_Callouts, hash_data, chars_avail)
911          block_pos += BLOCK_SIZE;
912          remaining -= BLOCK_SIZE;
913    }
914    block_base = block_pos;
915    if (remaining > 0 || @any_carry) {
916          EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-remaining));
917          s2p_do_final_block((BytePack *) &srcbuf[block_pos], basis_bits, EOF_mask);
918          @final_block_stmts
919          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
920          validation_do_block(lex, tag_Callouts, hash_data, chars_avail)
921    }
922    buf_pos += chars_avail;
923    buffer_base = buf_pos;
924
925    matcher.StreamScan(chars_avail);
926    matcher.Advance_buffer();
927    tracker.Advance_buffer();
928
929    PERF_SEC_END(parser_timer, chars_avail);
930    if (matcher.depth != 0) {
931      fprintf(stderr, "tag matching error (depth %i) at position %i\n", matcher.depth, buffer_base);
932      exit(-1);
933    }
934//  print_GIDS();
935//    pbgs_symbol_table.Print_Symbol_Table_Distribution();
936}
937
938
939
940int
941main(int argc, char * argv[]) {
942        char * infilename, * outfilename;
943        FILE *infile, *outfile;
944        struct stat fileinfo;
945       
946        ofile = fopen("gids.out","w");
947
948        if (argc < 2) {
949                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
950                exit(-1);
951        }
952
953        infilename = argv[1];
954        stat(infilename, &fileinfo);
955        infile = fopen(infilename, "rb");
956        if (!infile) {
957                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
958                exit(-1);
959        }
960
961        if (argc < 3) outfile = stdout;
962        else {
963                outfilename = argv[2];
964                outfile = fopen(outfilename, "wb");
965                if (!outfile) {
966                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
967                        exit(-1);
968                }
969        }
970
971//      PERF_SEC_BIND(1);
972
973        PERF_SEC_INIT(parser_timer);
974
975        do_process(infile, outfile);
976       
977#if DEBUG
978cout <<"gid_vectors:"<<endl;
979print_vecs();
980
981#endif
982       
983        validate_vecs();
984       
985        cout << "number of vectors: " << elem_vec_map.size()<<endl;
986
987        PERF_SEC_DUMP(parser_timer);
988
989        PERF_SEC_DESTROY(parser_timer);
990
991        fclose(infile);
992        fclose(outfile);
993
994        printf ("Done procressing\n");
995        return(0);
996}
Note: See TracBrowser for help on using the repository browser.