source: proto/xmlschema/validation_template_onevec.cpp @ 3218

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

project checkin

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