source: proto/xmlschema/symtab_pbgs_template.cpp @ 3027

Last change on this file since 3027 was 2219, checked in by shiyangy, 7 years ago

project checkin

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