source: proto/SymbolTable/symtab_pbgs_div_template.cpp @ 1228

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

Integrated symbol table with xmlwf. There are various implementations for the symbol table, please read /proto/SymbolTable/README_SymbolTable for more information.

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