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