source: proto/PDF/pablo_template_pdf.cpp @ 2908

Last change on this file since 2908 was 2821, checked in by cameron, 6 years ago

Make sure that pabloSupport.hpp is included

File size: 18.5 KB
Line 
1#include <stdio.h>
2#include <stdlib.h>
3#include <errno.h>
4#include <sys/types.h>
5#include <sys/stat.h>
6#include <iostream>
7using namespace std;
8
9#define LocalCarryDeclare(name, count)\
10CarryArray<count, 0> name;\
11
12#include <simd-lib/bitblock.hpp>
13#include <simd-lib/carryQ.hpp>
14#include <simd-lib/pabloSupport.hpp>
15#include <simd-lib/bitblock_iterator.hpp>
16#include <simd-lib/s2p.hpp>
17#include <simd-lib/buffer.hpp>
18#include <perflib/perfsec.h>
19
20static unsigned int depth = 0;
21static string outstring="";
22static int startpos=0;
23static int val=0;
24static int cur_state;
25
26
27
28
29
30#define has_bit(x) (x != 0)
31template <class bitblock_t, class scanblock_t>
32class DualScanner: public Scanner<bitblock_t, scanblock_t> {
33protected:
34        const bitblock_t * strm1;
35        const bitblock_t * strm2;
36       
37        int block_count;
38        int32_t pos;
39        int32_t blk;
40        scanblock_t scan_blk1;
41        scanblock_t scan_blk2;
42public:
43
44        DualScanner(){}
45        DualScanner(const bitblock_t * s1, const bitblock_t * s2, int bit_block_count) {
46                init(s1,s2,bit_block_count);
47        }
48
49        IDISA_ALWAYS_INLINE void init(const bitblock_t * s1, const bitblock_t * s2, int bit_block_count) {
50               
51                this->strm1     = s1;
52                this->strm2     = s2;
53                this->pos = 0;
54                this->blk = 0;
55                this->scan_blk1 = *(scanblock_t *)s1;
56                this->scan_blk2 = *(scanblock_t *)s2;
57                this->block_count = bit_block_count*sizeof(bitblock_t)/sizeof(scanblock_t);
58        }
59
60        IDISA_ALWAYS_INLINE int32_t scan_to_next1() {
61                while (this->blk < this->block_count){
62                        if(has_bit(this->scan_blk1)){
63                                this->pos = scan_forward_zeroes(this->scan_blk1) + (this->blk * (sizeof(scanblock_t)*8));
64                                this->scan_blk1 = this->scan_blk1 & (this->scan_blk1-1);  // clear rightmost bit
65
66                                return (this->pos);
67                        }
68
69                        this->blk++;
70                        this->scan_blk1 = *((scanblock_t *)this->strm1 + this->blk);
71                        this->scan_blk2 = *((scanblock_t *)this->strm2 + this->blk);
72                };
73
74                this->pos = -1;
75                return (this->pos);
76        }
77        IDISA_ALWAYS_INLINE int32_t scan_to_next2() {
78                while (this->blk < this->block_count){
79                        if(has_bit(this->scan_blk2)){
80                                this->pos = scan_forward_zeroes(this->scan_blk2) + (this->blk * (sizeof(scanblock_t)*8));
81                                this->scan_blk2 = this->scan_blk2 & (this->scan_blk2-1);  // clear rightmost bit
82
83                                return (this->pos);
84                        }
85
86                        this->blk++;
87                        this->scan_blk1 = *((scanblock_t *)this->strm1 + this->blk);
88                        this->scan_blk2 = *((scanblock_t *)this->strm2 + this->blk);
89                };
90
91                this->pos = -1;
92                return (this->pos);
93        }
94       
95       
96
97        IDISA_ALWAYS_INLINE bool is_done() {return (-1==this->pos);}
98        IDISA_ALWAYS_INLINE int32_t get_pos() const {return this->pos;}
99
100        //static const int32_t BLOCK_COUNT = 16*sizeof(bitblock_t)/sizeof(scanblock_t);
101
102};
103#undef has_bit
104
105
106
107static inline void inc() {
108        depth++;
109}
110
111
112static inline void dec() {
113        depth--;
114}
115#define scan_to_next_and_test1(scanner, state) \
116        (scanner).scan_to_next1();\
117        if ((scanner).is_done()) {\
118                cur_state=state;\
119                return;\
120                }\
121               
122#define scan_to_next_and_test2(scanner, state) \
123        (scanner).scan_to_next2();\
124        if ((scanner).is_done()) {\
125                cur_state=state;\
126                return;\
127                }\
128       
129        //if ((*scanner).is_done())
130
131static BitBlock lt_zero() {
132        if (depth < 0) {
133                return simd<1>::constant<1>();
134        } else {
135                return simd<1>::constant<0>();
136        }
137}
138
139static BitBlock gt_zero() {
140        if (depth > 0) {
141                return simd<1>::constant<1>();
142        } else {
143                return simd<1>::constant<0>();
144        }
145}
146
147static BitBlock is_zero() {
148        if (0 == depth) {
149                return simd<1>::constant<1>();
150        } else {
151                return simd<1>::constant<0>();
152        }
153}
154
155// Define the mappings for pablo.assert_0(strm, errkind) statements which
156// compile to the the form assert_0_error(errkind, strm)
157#define assert_0_error(errkind, errstrm) error_tracker.NoteError(errkind, errstrm);
158
159#ifdef BUFFER_PROFILING
160    BOM_Table * parser_timer;
161#elif PAPI
162                #define PAPI_EVENTS_COUNT 2
163                int PAPI_EVENTS[PAPI_EVENTS_COUNT] = {PAPI_TOT_CYC, PAPI_BR_MSP};       
164    CC * parser_timer;
165#else
166    void * parser_timer;
167#endif
168
169BitBlock EOF_mask = simd<1>::constant<1>();
170
171//////////////////////////////////////////////////////////////////////////////////////////
172// Buffer Management
173//////////////////////////////////////////////////////////////////////////////////////////
174#define PADDING_BLOCKS 1
175#define PADDING_SIZE (BLOCK_SIZE * PADDING_BLOCKS)
176#define COPYBACK_BLOCKS 1
177#define COPYBACK_SIZE (BLOCK_SIZE * COPYBACK_BLOCKS)
178#define LOOKAHEAD_BLOCKS 0
179#define LOOKAHEAD_SIZE (BLOCK_SIZE * LOOKAHEAD_BLOCKS)
180#define SEGMENT_BLOCKS  16
181#define SEGMENT_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
182#define BUFFER_SIZE (COPYBACK_SIZE + SEGMENT_SIZE + LOOKAHEAD_SIZE + PADDING_SIZE)
183
184//////////////////////////////////////////////////////////////////////////////////////////
185// @ global depends on 'error_tracker' and 'EOF_mask' definitions.
186//////////////////////////////////////////////////////////////////////////////////////////
187@global
188
189//////////////////////////////////////////////////////////////////////////////////////////
190// Headers that depend @ global stream struct types.
191//////////////////////////////////////////////////////////////////////////////////////////
192#include <transpose.hpp>
193//#include <post_process.hpp>
194
195static void do_process(FILE *infile, FILE *outfile);
196
197int main(int argc, char * argv[]) {
198
199        char * infilename, * outfilename;
200        FILE *infile, *outfile;
201        struct stat fileinfo;
202
203        if (argc < 2) {
204                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
205                exit(-1);
206        }
207
208        infilename = argv[1];
209        stat(infilename, &fileinfo);
210        infile = fopen(infilename, "rb");
211        if (!infile) {
212                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
213                exit(-1);
214        }
215
216        if (argc < 3) outfile = stdout;
217        else {
218                outfilename = argv[2];
219                outfile = fopen(outfilename, "wb");
220                if (!outfile) {
221                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
222                        exit(-1);
223                }
224        }
225
226        PERF_SEC_BIND(1);
227
228        PERF_SEC_INIT(parser_timer);
229
230        do_process(infile, outfile);
231
232        PERF_SEC_DUMP(parser_timer);
233
234        PERF_SEC_DESTROY(parser_timer);
235
236        fclose(infile);
237        fclose(outfile);
238
239        return(0);
240}
241/*void print_register2(const char * var_name, BitBlock v, int length) {
242        unsigned char c;
243        printf("%10s = ", var_name);
244        for(int i=(length+7)/8; i>=0; i--) {
245                c = *(((unsigned char *)&v)+i);
246                int div = 128;
247                while (div > 0) {
248                        if (c>=div) {
249                                cout<<"1";
250                                c-=div;
251                        }
252                        else {
253                                cout<<"0";
254                        }
255                        div = div / 2;
256                }
257        }
258        printf("\n");
259}*/
260void print_register2(const char * var_name, BitBlock v, int length) {
261        unsigned char c;
262        printf("%10s = ", var_name);
263        for(int i=0;i<=(length+7)/8; i++) {
264                c = *(((unsigned char *)&v)+i);
265                int count = 0;
266                while (count < 8) {
267                        if ((c % 2)==1)
268                        {
269                                cout<<"1";
270                        }
271                        else {
272                                cout<<"0";
273                        }
274                        c = c / 2;
275                        count+=1;
276                }
277        }
278        printf("\n");
279}
280string get_substring(uint8_t * src_buffer, int start, int end) {
281        string out = "";
282        for (int i =start;i<end;i++) 
283        {
284                out+=src_buffer[i];
285        }
286        return out;
287}       
288
289void postprocess_do_block(BitBlock * starts, BitBlock * others, uint8_t * src_buffer,  int block_base, int bit_block_count, bool final) {
290               
291                int ch;
292                DualScanner<BitBlock, ScanWord> dscanner(starts, others, bit_block_count);
293
294                switch(cur_state){
295                        case 0:
296                                goto pos0;
297                        case 1:
298                                goto pos1;
299                        case 2:
300                                goto pos2;
301                        case 3:
302                                goto pos3;
303                        case 4:
304                                goto pos4;
305                        case 5:
306                                goto pos5;
307                        case 6:
308                                goto pos6;
309                        case 7:
310                                goto pos7;
311                        case 8:
312                                goto pos8;
313                        case 9:
314                                goto pos9;
315                        case 10:
316                                goto pos10;
317                        case 11:
318                                goto pos11;
319                }
320
321               
322                pos0: scan_to_next_and_test1(dscanner, 0);
323                while(!(dscanner).is_done()) {
324                        switch (src_buffer[block_base+(dscanner).get_pos()])
325                        {
326                                case '/':
327                                        cout<<"LexName:";
328                                        outstring = "";
329                                        startpos = block_base+(dscanner).get_pos();
330                                        pos1: scan_to_next_and_test2(dscanner, 1);
331                                       
332                                       
333                                        ch = src_buffer[block_base+(dscanner).get_pos()];
334                                        while (('0'<=ch && ch<='9') || ('A'<=ch && ch<='F') ||('a'<=ch && ch<='f')) {
335                                                outstring+=get_substring(src_buffer,startpos+1, block_base+(dscanner).get_pos()-2);
336                                                startpos = block_base+(dscanner).get_pos();
337                                                if (ch<='9')            val =  ch - '0';
338                                                else if (ch<='F')       val = 10 + ch - 'A';
339                                                else val = 10 + ch - 'a';
340                                                ch = src_buffer[block_base+(dscanner).get_pos()-1];
341                                               
342                                                if (ch<='9')            val = val + 16*(ch - '0');
343                                                else if (ch<='F')       val = val+16*(10 + ch - 'A');
344                                                else val = val+ 16*(10 + ch - 'a');
345                                                outstring+=val;
346                                                pos11: scan_to_next_and_test2(dscanner, 11);
347                                                ch = src_buffer[block_base+(dscanner).get_pos()];
348                                        }
349                                        outstring+=get_substring(src_buffer,startpos+1,block_base+(dscanner).get_pos());
350                                        cout<<outstring<<endl;
351                       
352                                       
353                                        break;
354                                case '(':
355                                        cout<<"LexLiteralString:";
356                                        outstring="";
357                                        startpos = block_base+(dscanner).get_pos();
358                                       
359                                        //IMPLEMENT SEPARATE FINAL FUNCTION
360                                        pos2: if (final) {
361                                                dscanner.scan_to_next2();
362                                                if (dscanner.is_done()) {
363                                                        cout << "Corrupt string"<<endl;
364                                                        return;
365                                                }
366                                        }
367                                        else {
368                                                scan_to_next_and_test2(dscanner, 2);
369                                        }
370                                        while (!(dscanner).is_done()) {
371                                                outstring+=get_substring(src_buffer, startpos+1,block_base+(dscanner).get_pos());
372                                                if (src_buffer[block_base+(dscanner).get_pos()]==')') {
373                                                        cout<<outstring<<endl;
374                                                        break;
375                                                }
376                                                startpos=block_base+(dscanner).get_pos();
377                                                if (src_buffer[block_base+(dscanner).get_pos()]=='\\') {
378                                                        ch = src_buffer[block_base+(dscanner).get_pos()+1];
379                                                        switch (ch) {
380                                                                case 'n':
381                                                                        outstring+=0x0A;
382                                                                        break;
383                                                                case 'r':
384                                                                        outstring+=0x0D;
385                                                                        break;
386                                                                case 't':
387                                                                        outstring+=0x09;
388                                                                        break;
389                                                                case 'b':
390                                                                        outstring+=0x08;
391                                                                        break;
392                                                                case 'f':
393                                                                        outstring+=0x0C;
394                                                                        break;
395                                                                case '0': case '1':
396                                                                case '2': case '3':
397                                                                case '4': case '5':
398                                                                case '6': case '7':
399                                                                        val = ch - '0';
400                                                                        if ((src_buffer[block_base+(dscanner).get_pos()+2]) >= '0' && (src_buffer[block_base+(dscanner).get_pos()+2]<='8')) {
401                                                                                val = val*8 + src_buffer[block_base+(dscanner).get_pos()+2]-'0';
402                                                                                startpos+=1;
403                                                                                if ((src_buffer[block_base+(dscanner).get_pos()+3]) >= '0' && (src_buffer[block_base+(dscanner).get_pos()+3]<='8')) {
404                                                                                        val = val*8 + src_buffer[block_base+(dscanner).get_pos()+3]-'0';
405                                                                                        startpos+=1;
406                                                                                }
407                                                                        }
408                                                                        val = val & 0xFF;
409                                                                        outstring+=val;
410                                                                        break;
411                                                                case 13:
412                                                                        if (src_buffer[block_base+(dscanner).get_pos()+2]==10) {
413                                                                                startpos+=1;
414                                                                        }
415                                                                        break;
416                                                                case 10:
417                                                                        break;
418                                                                default:
419                                                                        outstring+=ch;
420                                                        }
421                                                        startpos+=1;
422                                       
423                                       
424                                                }
425                                                else {
426                                                        outstring+=0x0A;
427                                                        if (src_buffer[block_base+(dscanner).get_pos()+1]==0x0a) {
428                                                                startpos+=1;
429                                                        }
430                                                }
431                                               
432                                               
433                                                //IMPLEMENT SEPARATE FINAL FUNCTION
434                                                pos3: if (final) {
435                                                        dscanner.scan_to_next2();
436                                                        if (dscanner.is_done()) {
437                                                                cout << "Corrupt string"<<endl;
438                                                                return;
439                                                        }
440                                                }
441                                                else {
442                                                        scan_to_next_and_test2(dscanner, 3);
443                                                }
444                                        }
445                                       
446                                        if ((dscanner).is_done()) {
447                                                cout << "Corrupt string"<<endl;
448                                        }
449                                        break;
450                                case '0': case '1':
451                                case '2': case '3':
452                                case '4': case '5':
453                                case '6': case '7':
454                                case '8': case '9':
455                                case '.': case '+':
456                                case '-':
457                                        cout << "LexNumber:";
458                                               
459                                        startpos = block_base+(dscanner).get_pos();
460                                        pos4: scan_to_next_and_test2(dscanner, 4);
461                                       
462                                        outstring=get_substring(src_buffer,startpos,block_base+(dscanner).get_pos());
463                                        cout<<outstring<<endl;
464                                        break;
465                                case '<':
466                                        cout << "LexHexString:";
467                                        outstring="";
468                                        pos5: scan_to_next_and_test2(dscanner, 5);
469                                        ch = src_buffer[block_base+(dscanner).get_pos()];
470                                        while (('0'<=ch && ch<='9') || ('A'<=ch && ch<='F') ||('a'<=ch && ch<='f')) {
471                                                if (ch<='9')            val =  16*(ch - '0');
472                                                else if (ch<='F')       val = 16*(10 + ch - 'A');
473                                                else val = 16*(10 + ch - 'a');
474                                                pos6: scan_to_next_and_test2(dscanner, 6);
475                                                ch = src_buffer[block_base+(dscanner).get_pos()];
476                                                if (('0'<=ch && ch<='9') || ('A'<=ch && ch<='F') ||('a'<=ch && ch<='f')) {
477                                                        if (ch<='9')            val +=  (ch - '0');
478                                                        else if (ch<='F')       val += (10 + ch - 'A');
479                                                        else val += 10 + ch - 'a';
480                                                       
481                                                        //IMPLEMENT SEPARATE FINAL FUNCTION
482                                                        pos7: if (final) {
483                                                                dscanner.scan_to_next2();
484                                                                if (dscanner.is_done()) {
485                                                                        cout<<"BASE_ASSERT(false, \"Bad String\");"<<endl;
486                                                                        return;
487                                                                }
488                                                        }
489                                                        else {
490                                                                 scan_to_next_and_test2(dscanner, 7);   
491                                                        }
492                                                       
493                                                       
494                                                       
495                                                       
496                                                        ch = src_buffer[block_base+(dscanner).get_pos()];
497                                                }
498                                                outstring+=val;
499                                        }
500                                        if (ch !='>') {
501                                                cout<<"BASE_ASSERT(false, \"Bad String\");"<<endl;
502                                        }
503                                        else
504                                        {
505                                                cout<<outstring<<endl;
506                                        }                                       
507                                        break;
508                                case ')':
509                                        cout << "BASE_ASSERT(false, \"')' is not matched\");"<<endl;
510                                        break;
511                                case '[':
512                                        cout<<"Array Start"<<endl;
513                                        pos8: scan_to_next_and_test2(dscanner, 8);
514                                        break;
515                                default:
516                                        cout<<"LexDefault:";
517                                        startpos = block_base+(dscanner).get_pos();
518                                        pos9: scan_to_next_and_test2(dscanner, 9);
519                                        outstring = get_substring(src_buffer,startpos,block_base+(dscanner).get_pos());
520                                        if (outstring=="null") {
521                                                cout << "NULL OBJECT"<<endl;
522                                        } else if (outstring=="true") {
523                                                cout << "TRUE OBJECT"<<endl;
524                                        } else if (outstring =="false") {
525                                                cout << "FALSE OBJECT"<<endl;
526                                        } else {
527                                                cout << "RETURN FALSE:"<<outstring<<endl;
528                                        }
529                                       
530                                }
531                               
532
533                        if(!(dscanner).is_done()) {
534                                pos10: scan_to_next_and_test1(dscanner, 10);
535
536                        }
537                }
538                 
539                 
540                 
541                 
542                 
543                 
544                 
545                 
546                 
547                 
548                 
549
550
551
552
553
554}
555
556void do_process(FILE *infile, FILE *outfile) {
557        @decl
558
559        /* Extras */
560        parity.odd = simd<2>::constant<1>();
561        parity.even = simd<2>::constant<2>();
562
563        int block_base = 0;
564        int block_pos = 0;
565        int chars_avail = 0;
566        int chars_read = 0;
567        int padding_read = 0;
568        int remaining = 0;
569BitBlock starts[SEGMENT_SIZE];
570BitBlock others[SEGMENT_SIZE];
571  /* Tracked for post processing */
572        //int buffer_base=0;
573        //int buffer_pos = 0;
574
575        //////////////////////////////////////////////////////////////////////////////////////////
576        // Buffer Management
577        //////////////////////////////////////////////////////////////////////////////////////////
578        uint8_t * src_buffer;
579        ALLOC_STATIC_ALIGNED_BYTE_BUFFER(src_buffer, BUFFER_SIZE);
580   
581        //////////////////////////////////////////////////////////////////////////////////////////
582        // Initial file read
583        //////////////////////////////////////////////////////////////////////////////////////////
584        chars_read = fread((void *)&src_buffer[COPYBACK_SIZE], 1, SEGMENT_SIZE + LOOKAHEAD_SIZE, infile);
585        remaining = chars_read;
586        chars_avail = chars_read;       
587        padding_read = chars_read - SEGMENT_SIZE;
588int position = 0;
589        if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
590
591        @stream_stmts
592
593        //////////////////////////////////////////////////////////////////////////////////////////
594        // Processs Full Segments
595        //////////////////////////////////////////////////////////////////////////////////////////
596        while (chars_avail >= SEGMENT_SIZE) {
597          PERF_SEC_START(parser_timer);
598          for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
599                  block_base = blk*BLOCK_SIZE+COPYBACK_SIZE;
600                  s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
601
602                        #ifdef PDF_DEBUG
603                        for (int i = 0; i < BLOCK_SIZE; i++) {
604                                cout << src_buffer[block_base + i];
605                        }
606                        #endif
607
608                  @block_stmts
609      starts[blk]=marker.starts;
610          others[blk]=marker.others;
611                  //postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)src_buffer, buffer_base, block_base,chars_avail, tracker);
612
613          }
614
615                postprocess_do_block(&starts[0], &others[0], &src_buffer[COPYBACK_SIZE-position],  position, SEGMENT_BLOCKS, false);   
616        position+=SEGMENT_BLOCKS*128;
617
618
619          PERF_SEC_END(parser_timer, chars_avail);
620
621                remaining -= SEGMENT_SIZE;
622          memmove(src_buffer, &src_buffer[SEGMENT_SIZE-COPYBACK_SIZE], padding_read+COPYBACK_SIZE); 
623          chars_read = fread(&src_buffer[padding_read+COPYBACK_SIZE], 1, (SEGMENT_SIZE + LOOKAHEAD_SIZE - padding_read), infile);
624                padding_read = chars_read-(SEGMENT_SIZE + LOOKAHEAD_SIZE - padding_read) ;//chars_read;
625
626                remaining += chars_read;
627                chars_avail = remaining;
628
629                if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
630
631    /* Tracked for post processing */
632          // buffer_pos += chars_avail;
633          // buffer_base = buffer_pos;
634
635        }
636
637        //////////////////////////////////////////////////////////////////////////////////////////
638        // Final Partial Segment
639        //////////////////////////////////////////////////////////////////////////////////////////
640        PERF_SEC_START(parser_timer);
641
642        block_base = COPYBACK_SIZE;
643
644        /* Full Blocks */
645        uint32_t blk = 0;
646        while (remaining >= BLOCK_SIZE) {
647       
648                        #ifdef PDF_DEBUG
649                        for(int i = 0; i < BLOCK_SIZE; i++) {
650                                cout << src_buffer[block_base + i];
651                        }
652                        #endif         
653
654                  s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
655                  @block_stmts
656
657      starts[blk]=marker.starts;
658          others[blk]=marker.others;
659       //postprocess_do_block(&(marker.starts), &(marker.others), src_buffer,  block_base);
660
661                  block_base += BLOCK_SIZE;
662                  remaining -= BLOCK_SIZE;
663                  blk++;
664        }
665
666        /* Partial Block or Any Carry */
667        if (remaining > 0 || @any_carry) {
668
669                        #ifdef PDF_DEBUG
670                        for(int i = 0; i < remaining; i++) 
671                        {                               
672                                std::cout << src_buffer[block_base+i];
673                        }
674                        #endif
675
676                  EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
677                  s2p_do_final_block((BytePack *) &src_buffer[block_base], basis_bits, EOF_mask);
678                  @final_block_stmts
679                  //print_register2("markstarts",marker.starts,remaining);
680                 
681                 
682                    starts[blk]=marker.starts;
683                        others[blk]=marker.others;
684                 
685       //postprocess_do_block(&(marker.starts), &(marker.others), src_buffer,  block_base);
686                  blk++;
687        }
688
689        /* Tracked for post processing */
690        // buffer_pos += chars_avail;
691        // buffer_base = buffer_pos;
692//postprocess_do_block(starts, others, src_buffer,  0, 1, blk==1);     
693//if (blk>1){
694postprocess_do_block(&starts[0], &others[0], &src_buffer[COPYBACK_SIZE-position],  position, blk, true);       
695//}
696        PERF_SEC_END(parser_timer, chars_avail);
697}
698
Note: See TracBrowser for help on using the repository browser.