source: proto/PDF/pablo_template_pdf.cpp @ 2629

Last change on this file since 2629 was 2629, checked in by bhull, 7 years ago

Added token output for compiled version

File size: 14.0 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;
20
21static inline void inc() {
22        depth++;
23}
24
25static inline void dec() {
26        depth--;
27}
28
29static BitBlock lt_zero() {
30        if (depth < 0) {
31                return simd<1>::constant<1>();
32        } else {
33                return simd<1>::constant<0>();
34        }
35}
36
37static BitBlock gt_zero() {
38        if (depth > 0) {
39                return simd<1>::constant<1>();
40        } else {
41                return simd<1>::constant<0>();
42        }
43}
44
45static BitBlock is_zero() {
46        if (0 == depth) {
47                return simd<1>::constant<1>();
48        } else {
49                return simd<1>::constant<0>();
50        }
51}
52
53// Define the mappings for pablo.assert_0(strm, errkind) statements which
54// compile to the the form assert_0_error(errkind, strm)
55#define assert_0_error(errkind, errstrm) error_tracker.NoteError(errkind, errstrm);
56
57#ifdef BUFFER_PROFILING
58    BOM_Table * parser_timer;
59#elif PAPI
60                #define PAPI_EVENTS_COUNT 2
61                int PAPI_EVENTS[PAPI_EVENTS_COUNT] = {PAPI_TOT_CYC, PAPI_BR_MSP};       
62    CC * parser_timer;
63#else
64    void * parser_timer;
65#endif
66
67BitBlock EOF_mask = simd<1>::constant<1>();
68
69//////////////////////////////////////////////////////////////////////////////////////////
70// Buffer Management
71//////////////////////////////////////////////////////////////////////////////////////////
72#define PADDING_BLOCKS 1
73#define PADDING_SIZE (BLOCK_SIZE * PADDING_BLOCKS)
74#define COPYBACK_BLOCKS 0
75#define COPYBACK_SIZE (BLOCK_SIZE * COPYBACK_BLOCKS)
76#define LOOKAHEAD_BLOCKS 1
77#define LOOKAHEAD_SIZE (BLOCK_SIZE * LOOKAHEAD_BLOCKS)
78#define SEGMENT_BLOCKS  4
79#define SEGMENT_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
80#define BUFFER_SIZE (COPYBACK_SIZE + SEGMENT_SIZE + LOOKAHEAD_SIZE + PADDING_SIZE)
81
82//////////////////////////////////////////////////////////////////////////////////////////
83// @ global depends on 'error_tracker' and 'EOF_mask' definitions.
84//////////////////////////////////////////////////////////////////////////////////////////
85@global
86
87//////////////////////////////////////////////////////////////////////////////////////////
88// Headers that depend @ global stream struct types.
89//////////////////////////////////////////////////////////////////////////////////////////
90#include <transpose.hpp>
91//#include <post_process.hpp>
92
93static void do_process(FILE *infile, FILE *outfile);
94
95int main(int argc, char * argv[]) {
96
97        char * infilename, * outfilename;
98        FILE *infile, *outfile;
99        struct stat fileinfo;
100
101        if (argc < 2) {
102                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
103                exit(-1);
104        }
105
106        infilename = argv[1];
107        stat(infilename, &fileinfo);
108        infile = fopen(infilename, "rb");
109        if (!infile) {
110                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
111                exit(-1);
112        }
113
114        if (argc < 3) outfile = stdout;
115        else {
116                outfilename = argv[2];
117                outfile = fopen(outfilename, "wb");
118                if (!outfile) {
119                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
120                        exit(-1);
121                }
122        }
123
124        PERF_SEC_BIND(1);
125
126        PERF_SEC_INIT(parser_timer);
127
128        do_process(infile, outfile);
129
130        PERF_SEC_DUMP(parser_timer);
131
132        PERF_SEC_DESTROY(parser_timer);
133
134        fclose(infile);
135        fclose(outfile);
136
137        return(0);
138}
139/*void print_register2(const char * var_name, BitBlock v, int length) {
140        unsigned char c;
141        printf("%10s = ", var_name);
142        for(int i=(length+7)/8; i>=0; i--) {
143                c = *(((unsigned char *)&v)+i);
144                int div = 128;
145                while (div > 0) {
146                        if (c>=div) {
147                                cout<<"1";
148                                c-=div;
149                        }
150                        else {
151                                cout<<"0";
152                        }
153                        div = div / 2;
154                }
155        }
156        printf("\n");
157}*/
158void print_register2(const char * var_name, BitBlock v, int length) {
159        unsigned char c;
160        printf("%10s = ", var_name);
161        for(int i=0;i<=(length+7)/8; i++) {
162                c = *(((unsigned char *)&v)+i);
163                int count = 0;
164                while (count < 8) {
165                        if ((c % 2)==1)
166                        {
167                                cout<<"1";
168                        }
169                        else {
170                                cout<<"0";
171                        }
172                        c = c / 2;
173                        count+=1;
174                }
175        }
176        printf("\n");
177}
178string get_substring(uint8_t * src_buffer, int start, int end) {
179        string out = "";
180        for (int i =start;i<end;i++) 
181        {
182                out+=src_buffer[i];
183        }
184        return out;
185}       
186void do_process(FILE *infile, FILE *outfile) {
187        @decl
188
189        /* Extras */
190        parity.odd = simd<2>::constant<1>();
191        parity.even = simd<2>::constant<2>();
192
193        int block_base = 0;
194        int block_pos = 0;
195        int chars_avail = 0;
196        int chars_read = 0;
197        int padding_read = 0;
198        int remaining = 0;
199
200  /* Tracked for post processing */
201        //int buffer_base=0;
202        //int buffer_pos = 0;
203
204        //////////////////////////////////////////////////////////////////////////////////////////
205        // Buffer Management
206        //////////////////////////////////////////////////////////////////////////////////////////
207        uint8_t * src_buffer;
208        ALLOC_STATIC_ALIGNED_BYTE_BUFFER(src_buffer, BUFFER_SIZE);
209   
210        //////////////////////////////////////////////////////////////////////////////////////////
211        // Initial file read
212        //////////////////////////////////////////////////////////////////////////////////////////
213        chars_read = fread((void *)src_buffer, 1, SEGMENT_SIZE + LOOKAHEAD_SIZE, infile);
214        remaining = chars_read;
215        chars_avail = chars_read;       
216        padding_read = chars_read - SEGMENT_SIZE;
217
218        if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
219
220        @stream_stmts
221
222        //////////////////////////////////////////////////////////////////////////////////////////
223        // Processs Full Segments
224        //////////////////////////////////////////////////////////////////////////////////////////
225        while (chars_avail >= SEGMENT_SIZE) {
226          PERF_SEC_START(parser_timer);
227          for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
228                  block_base = blk*BLOCK_SIZE;
229                  s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
230
231                        #ifdef PDF_DEBUG
232                        for (int i = 0; i < BLOCK_SIZE; i++) {
233                                cout << src_buffer[block_base + i];
234                        }
235                        #endif
236
237                  @block_stmts
238
239                  //postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)src_buffer, buffer_base, block_base,chars_avail, tracker);
240
241          }
242          PERF_SEC_END(parser_timer, chars_avail);
243
244                remaining -= SEGMENT_SIZE;
245          memmove(src_buffer, &src_buffer[SEGMENT_SIZE], padding_read); 
246          chars_read = fread(&src_buffer[padding_read], 1, (SEGMENT_SIZE + LOOKAHEAD_SIZE - padding_read), infile);
247
248                padding_read = SEGMENT_SIZE + LOOKAHEAD_SIZE - padding_read ;//chars_read;
249
250                remaining += chars_read;
251                chars_avail = remaining;
252
253                if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
254
255    /* Tracked for post processing */
256          // buffer_pos += chars_avail;
257          // buffer_base = buffer_pos;
258
259        }
260
261        //////////////////////////////////////////////////////////////////////////////////////////
262        // Final Partial Segment
263        //////////////////////////////////////////////////////////////////////////////////////////
264        PERF_SEC_START(parser_timer);
265
266        block_base = 0;
267
268        /* Full Blocks */
269        uint32_t blk = 0;
270        while (remaining >= BLOCK_SIZE) {
271       
272                        #ifdef PDF_DEBUG
273                        for(int i = 0; i < BLOCK_SIZE; i++) {
274                                cout << src_buffer[block_base + i];
275                        }
276                        #endif         
277
278                  s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
279                  @block_stmts
280
281      // postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)src_buffer, buffer_base, block_base, chars_avail, tracker);
282
283                  block_base += BLOCK_SIZE;
284                  remaining -= BLOCK_SIZE;
285                  blk++;
286        }
287
288        /* Partial Block or Any Carry */
289        if (remaining > 0 || @any_carry) {
290
291                        #ifdef PDF_DEBUG
292                        for(int i = 0; i < remaining; i++) 
293                        {                               
294                                std::cout << src_buffer[block_base+i];
295                        }
296                        #endif
297
298                  EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
299                  s2p_do_final_block((BytePack *) &src_buffer[block_base], basis_bits, EOF_mask);
300                  @final_block_stmts
301                  //print_register2("markstarts",marker.starts,remaining);
302                 
303                 
304                string outstring;
305                int startpos;
306                int ch;
307                int val;
308                ForwardScanner<BitBlock, ScanWord> scanner(&(marker.starts));
309                scanner.scan_to_next();
310                while(!scanner.is_done()) {
311                        switch (src_buffer[scanner.get_pos()])
312                        {
313                                case '/':
314                                        cout<<"LexName:";
315                                        outstring = "";
316                                        startpos = scanner.get_pos();
317                                        scanner.set_strm(&(marker.others));
318                                        scanner.move_to(scanner.get_pos());
319                                        scanner.scan_to_next();
320                                       
321                                       
322                                        ch = src_buffer[scanner.get_pos()];
323                                        while (('0'<=ch && ch<='9') || ('A'<=ch && ch<='F') ||('a'<=ch && ch<='f')) {
324                                                outstring+=get_substring(src_buffer,startpos+1, scanner.get_pos()-2);
325                                                startpos = scanner.get_pos();
326                                                if (ch<='9')            val =  ch - '0';
327                                                else if (ch<='F')       val = 10 + ch - 'A';
328                                                else val = 10 + ch - 'a';
329                                                ch = src_buffer[scanner.get_pos()-1];
330                                               
331                                                if (ch<='9')            val = val + 16*(ch - '0');
332                                                else if (ch<='F')       val = val+16*(10 + ch - 'A');
333                                                else val = val+ 16*(10 + ch - 'a');
334                                                outstring+=val;
335                                                scanner.scan_to_next();
336                                                ch = src_buffer[scanner.get_pos()];
337                                        }
338                                        outstring+=get_substring(src_buffer,startpos+1,scanner.get_pos());
339                                        scanner.set_strm(&(marker.starts));
340                                        scanner.move_to(scanner.get_pos()-1);
341                                        cout<<outstring<<endl;
342                       
343                                       
344                                        break;
345                                case '(':
346                                        cout<<"LexLiteralString:";
347                                        outstring="";
348                                        startpos = scanner.get_pos();
349                                        scanner.set_strm(&(marker.others));
350                                        scanner.move_to(scanner.get_pos());
351                                        scanner.scan_to_next();
352                                        while (!scanner.is_done()) {
353                                                outstring+=get_substring(src_buffer, startpos+1,scanner.get_pos());
354                                                if (src_buffer[scanner.get_pos()]==')') {
355                                                        cout<<outstring<<endl;
356                                                        break;
357                                                }
358                                                startpos=scanner.get_pos();
359                                                if (src_buffer[scanner.get_pos()]=='\\') {
360                                                        ch = src_buffer[scanner.get_pos()+1];
361                                                        switch (ch) {
362                                                                case 'n':
363                                                                        outstring+=0x0A;
364                                                                        break;
365                                                                case 'r':
366                                                                        outstring+=0x0D;
367                                                                        break;
368                                                                case 't':
369                                                                        outstring+=0x09;
370                                                                        break;
371                                                                case 'b':
372                                                                        outstring+=0x08;
373                                                                        break;
374                                                                case 'f':
375                                                                        outstring+=0x0C;
376                                                                        break;
377                                                                case 0: case 1:
378                                                                case 2: case 3:
379                                                                case 4: case 5:
380                                                                case 6: case 7:
381                                                                        val = ch - '0';
382                                                                        if ((src_buffer[scanner.get_pos()+2]) >= '0' && (src_buffer[scanner.get_pos()+2]<='8')) {
383                                                                                val = val*8 + src_buffer[scanner.get_pos()+2]-'0';
384                                                                                startpos+=1;
385                                                                                if ((src_buffer[scanner.get_pos()+3]) >= '0' && (src_buffer[scanner.get_pos()+3]<='8')) {
386                                                                                        val = val*8 + src_buffer[scanner.get_pos()+3]-'0';
387                                                                                        startpos+=1;
388                                                                                }
389                                                                        }
390                                                                        val = val & 0xFF;
391                                                                        outstring+=val;
392                                                                        break;
393                                                                case 13:
394                                                                        if (src_buffer[scanner.get_pos()+2]==10) {
395                                                                                startpos+=1;
396                                                                        }
397                                                                        break;
398                                                                case 10:
399                                                                        break;
400                                                                default:
401                                                                        outstring+=ch;
402                                                        }
403                                                        startpos+=1;
404                                       
405                                       
406                                                }
407                                                else {
408                                                        outstring+=0x0A;
409                                                        if (src_buffer[scanner.get_pos()+1]==0x0a) {
410                                                                startpos+=1;
411                                                        }
412                                                }
413                                                scanner.scan_to_next();
414                                        }
415                                       
416                                        if (scanner.is_done()) {
417                                                cout << "Corrupt string"<<endl;
418                                        }
419                                        scanner.set_strm(&(marker.starts));
420                                        scanner.move_to(scanner.get_pos()-1);
421                                        break;
422                                case '0': case '1':
423                                case '2': case '3':
424                                case '4': case '5':
425                                case '6': case '7':
426                                case '8': case '9':
427                                case '.': case '+':
428                                case '-':
429                                        cout << "LexNumber:";
430                                               
431                                        startpos = scanner.get_pos();
432                                        scanner.set_strm(&(marker.others));
433                                        scanner.move_to(scanner.get_pos());
434                                        scanner.scan_to_next();
435                                       
436                                        outstring=get_substring(src_buffer,startpos,scanner.get_pos());
437                                        scanner.set_strm(&(marker.starts));
438                                        scanner.move_to(scanner.get_pos()-1);
439                                        cout<<outstring<<endl;
440                                        break;
441                                case '<':
442                                        cout << "LexHexString:";
443                                        outstring="";
444                                        scanner.set_strm(&(marker.others));
445                                        scanner.move_to(scanner.get_pos());
446                                        scanner.scan_to_next();
447                                        ch = src_buffer[scanner.get_pos()];
448                                        while (('0'<=ch && ch<='9') || ('A'<=ch && ch<='F') ||('a'<=ch && ch<='f')) {
449                                                if (ch<='9')            val =  16*(ch - '0');
450                                                else if (ch<='F')       val = 16*(10 + ch - 'A');
451                                                else val = 16*(10 + ch - 'a');
452                                                scanner.scan_to_next();
453                                                ch = src_buffer[scanner.get_pos()];
454                                                if (('0'<=ch && ch<='9') || ('A'<=ch && ch<='F') ||('a'<=ch && ch<='f')) {
455                                                        if (ch<='9')            val +=  (ch - '0');
456                                                        else if (ch<='F')       val += (10 + ch - 'A');
457                                                        else val += 10 + ch - 'a';
458                                                        scanner.scan_to_next();
459                                                        ch = src_buffer[scanner.get_pos()];
460                                                }
461                                                outstring+=val;
462                                        }
463                                        if (ch !='>') {
464                                                cout<<"BASE_ASSERT(false, \"Bad String\");"<<endl;
465                                        }
466                                        else
467                                        {
468                                                cout<<outstring<<endl;
469                                        }
470                                        scanner.set_strm(&(marker.starts));
471                                        scanner.move_to(scanner.get_pos()-1);                                   
472                                        break;
473                                case ')':
474                                        cout << "BASE_ASSERT(false, \"')' is not matched\");"<<endl;//"BASE_ASSERT(false, "\')\' is not matched");"
475                                        break;
476                                case '[':
477                                        cout<<"Array Start"<<endl;
478                                        scanner.set_strm(&(marker.others));
479                                        scanner.move_to(scanner.get_pos());
480                                        scanner.scan_to_next();
481                                        scanner.set_strm(&(marker.starts));
482                                       
483                                        scanner.move_to(scanner.get_pos()-1);
484                                        break;
485                                default:
486                                        cout<<"LexDefault:";
487                                        startpos = scanner.get_pos();
488                                        scanner.set_strm(&(marker.others));
489                                        scanner.move_to(scanner.get_pos());
490                                        scanner.scan_to_next();
491                                        outstring = get_substring(src_buffer,startpos,scanner.get_pos());
492                                        if (outstring=="null") {
493                                                cout << "NULL OBJECT"<<endl;
494                                        } else if (outstring=="true") {
495                                                cout << "TRUE OBJECT"<<endl;
496                                        } else if (outstring =="false") {
497                                                cout << "FALSE OBJECT"<<endl;
498                                        } else {
499                                                cout << "RETURN FALSE:"<<outstring<<endl;
500                                        }
501                                        scanner.set_strm(&(marker.starts));
502                                        scanner.move_to(scanner.get_pos()-1);
503                                       
504                                }
505                               
506
507                        if(!scanner.is_done()) {
508                                scanner.scan_to_next();
509                        }
510                }
511                 
512                 
513                 
514                 
515                 
516                 
517                 
518                 
519                 
520                 
521                 
522                 
523                 
524      // postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)src_buffer, buffer_base, block_base, chars_avail, tracker);
525                  blk++;
526        }
527
528        /* Tracked for post processing */
529        // buffer_pos += chars_avail;
530        // buffer_base = buffer_pos;
531
532        PERF_SEC_END(parser_timer, chars_avail);
533}
534
Note: See TracBrowser for help on using the repository browser.