source: proto/SymbolTable/symtab_pbgs_identity_template.cpp @ 1766

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

SymbolTable?: completed dictionary implementation and refactored templates

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