source: proto/SymbolTable/symtab_pbgs_identity_template.cpp @ 1684

Last change on this file since 1684 was 1684, checked in by vla24, 8 years ago

SymbolTable?: updated templates implementation to use BitBlockForwardIterator?. Fixed block boundary case handling for div2 grouping strategy.

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