source: proto/SymbolTable/symtab_pbgs_log_template.cpp @ 1231

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

Updated symbol table implementation: we are no longer using different implementation for symbol length 17-32 and symbol longer than 32 characters

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