source: proto/SymbolTable/symtab_pbgs_identity_template.cpp @ 1787

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

Added some code to support performance tests using PAPI

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