source: proto/SymbolTable/symtab_pbgs_identity_template.cpp @ 3076

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

Fixed macro names. I got L1 and L2 mixed up

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