source: proto/SymbolTable/symtab_pbgs_log_template.cpp @ 1491

Last change on this file since 1491 was 1491, checked in by ksherdy, 8 years ago

Removed direct .cpp #include.

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