source: proto/SymbolTable/symtab_pbgs_template.cpp @ 1442

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

SymbolTable?: Fixed integration with IDISA, it does not work well for pbgs_log and pbgs_id_adv. Changed bitutil.* to pablo.* for compiler generated files

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