source: proto/PDF/pablo_template_pdf.cpp @ 2814

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