source: proto/SymbolTable/symtab_pbgs_div_template.cpp @ 1499

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

SymbolTable?: Updated compile errors for idisa compile option

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