source: proto/parabix2/pablo_template.cpp @ 2209

Last change on this file since 2209 was 2206, checked in by cameron, 7 years ago

Added pablo.advance(strm, n) support (non-nested).

File size: 9.2 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
7#define LocalCarryDeclare(name, count)\
8CarryArray<count, 0> name;\
9
10#include "../lib/bitblock.hpp"
11#include "../lib/carryQ.hpp"
12#include "../lib/bitstream_iterator.hpp"
13#include "../lib/bitblock_iterator.hpp"
14#include "../lib/s2p.hpp"
15#include "../lib/perflib/perfsec.h"
16
17#include <xmldecl.h>
18#include <namechars.h>
19#include <TagMatcher.hpp>
20#include <LineColTracker.hpp>
21#include <ErrorUtil.h>
22#include <ErrorTracker.h>
23#include <XMLTestSuiteError.h>
24
25// Define the mappings for pablo.assert_0(strm, errkind) statements which
26// compile to the the form assert_0_error(errkind, strm)
27#define assert_0_error(errkind, errstrm) error_tracker.NoteError(errkind, errstrm);
28
29#ifdef BUFFER_PROFILING
30    BOM_Table * parser_timer;
31#elif CODE_CLOCKER
32    //#define NUM_EVENTS 1
33    //int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
34    //int Events[NUM_EVENTS] = {PAPI_L2_DCM};
35    #define NUM_EVENTS 2
36    int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
37    int cal_size = 20;
38    CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
39#else
40    void * parser_timer;
41#endif
42
43ErrorTracker error_tracker;
44BitBlock EOF_mask = simd<1>::constant<1>();
45
46//////////////////////////////////////////////////////////////////////////////////////////
47// Buffer Management // WARNING: Do Not update #defines. Results in TagMatcher errors.
48//////////////////////////////////////////////////////////////////////////////////////////
49#define PADDING_BLOCKS 0
50#define PADDING_SIZE (BLOCK_SIZE * PADDING_BLOCKS)
51#define COPYBACK_BLOCKS 2
52#define COPYBACK_SIZE (BLOCK_SIZE * COPYBACK_BLOCKS)
53#define LOOKAHEAD_BLOCKS 1
54#define LOOKAHEAD_SIZE (BLOCK_SIZE * LOOKAHEAD_BLOCKS)
55#define SEGMENT_BLOCKS  12 // WARNING: TagMatcher.hpp causes xmlconf test suite failures for SEGMENT_BLOCKS < 3.
56#define SEGMENT_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
57#define BUFFER_SIZE (COPYBACK_SIZE + SEGMENT_SIZE + LOOKAHEAD_SIZE + PADDING_SIZE)
58
59//////////////////////////////////////////////////////////////////////////////////////////
60// @ global depends on 'error_tracker' and 'EOF_mask' definitions.
61//////////////////////////////////////////////////////////////////////////////////////////
62@global
63
64//////////////////////////////////////////////////////////////////////////////////////////
65// Headers that depend @ global stream struct types.
66//////////////////////////////////////////////////////////////////////////////////////////
67#include "../lib/transpose.hpp"
68#include <post_process.hpp>
69
70static void do_process(FILE *infile, FILE *outfile);
71
72int main(int argc, char * argv[]) {
73
74        char * infilename, * outfilename;
75        FILE *infile, *outfile;
76        struct stat fileinfo;
77
78        if (argc < 2) {
79                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
80                exit(-1);
81        }
82
83        infilename = argv[1];
84        stat(infilename, &fileinfo);
85        infile = fopen(infilename, "rb");
86        if (!infile) {
87                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
88                exit(-1);
89        }
90
91        if (argc < 3) outfile = stdout;
92        else {
93                outfilename = argv[2];
94                outfile = fopen(outfilename, "wb");
95                if (!outfile) {
96                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
97                        exit(-1);
98                }
99        }
100
101        PERF_SEC_BIND(1);
102
103        PERF_SEC_INIT(parser_timer);
104
105        do_process(infile, outfile);
106
107        PERF_SEC_DUMP(parser_timer);
108
109        PERF_SEC_DESTROY(parser_timer);
110
111        fclose(infile);
112        fclose(outfile);
113
114        return(0);
115}
116
117void do_process(FILE *infile, FILE *outfile) {
118
119    @decl
120
121    LineColTracker tracker;
122        TagMatcher<SEGMENT_SIZE,LOOKAHEAD_SIZE> matcher;
123
124    int block_base=0;
125        int block_pos = 0;
126    int buffer_base=0;
127    int buffer_pos = 0;
128    int chars_avail = 0;
129        int chars_read = 0;
130
131    //////////////////////////////////////////////////////////////////////////////////////////
132    // Buffer Management
133    //////////////////////////////////////////////////////////////////////////////////////////
134        //      BitBlock buf[(BUFFER_SIZE)/sizeof(BitBlock)];
135        //      uint8_t * src_buffer = (uint8_t *)buf + COPYBACK_SIZE;
136
137        #include "../lib/buffer.hpp"
138        uint8_t * COPYBACK;
139        uint8_t * src_buffer;
140        ALLOC_STATIC_ALIGNED_BYTE_BUFFER_WITH_COPYBACK(COPYBACK, src_buffer);
141       
142    //////////////////////////////////////////////////////////////////////////////////////////
143    // XML Validation / Content Model
144    //////////////////////////////////////////////////////////////////////////////////////////
145        chars_read = fread((void *)src_buffer, 1, SEGMENT_SIZE, infile);
146        chars_avail = chars_read;
147        if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
148
149    if(chars_read<4){
150                fprintf(stderr,"File is too short. Not well formed.\n");
151                exit(-1);
152    }
153
154    Entity_Info * e = new Entity_Info;
155        e->AnalyzeSignature((unsigned char *)src_buffer);
156
157    if (e->code_unit_base == ASCII) {
158
159                XML_Decl_Parser<ASCII> decl_parser((unsigned char *)src_buffer);
160
161                decl_parser.ReadXMLInfo(*e);
162
163                if (e->code_unit_size != SingleByte || (e->has_encoding_decl && (!at_UTF_8(e->encoding)))){
164                        fprintf(stderr,"Sorry, this xmlwf demo only works for UTF-8.\n");
165                        exit(-1);
166                }
167    }
168    else {
169        fprintf(stderr,"Sorry, this xmlwf demo does not process EBCDIC.\n");
170        exit(-1);
171    }
172
173    if (e->content_start != 0) {
174
175                memmove(&src_buffer[0], &src_buffer[e->content_start], chars_avail - e->content_start);
176                buffer_pos = e->content_start;
177                if ((chars_avail-e->content_start) < SEGMENT_SIZE) {
178                        chars_read = chars_avail - e->content_start + fread(&src_buffer[chars_avail-e->content_start], 1, e->content_start, infile);
179                        chars_avail = chars_read;
180                }
181                if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
182    }
183
184        //////////////////////////////////////////////////////////////////////////////////////////
185        // Read OVERLAP bytes to support post processing validation lookahead.
186        //////////////////////////////////////////////////////////////////////////////////////////
187        chars_read = chars_avail + fread(&src_buffer[chars_avail], 1, LOOKAHEAD_SIZE, infile);
188        chars_avail = chars_read;
189        if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
190
191    @stream_stmts
192
193    //////////////////////////////////////////////////////////////////////////////////////////
194    // Full Segments
195    //////////////////////////////////////////////////////////////////////////////////////////
196        matcher.setSrc((char *)src_buffer);
197        while (chars_avail >= SEGMENT_SIZE) {
198      PERF_SEC_START(parser_timer);
199      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
200          block_base = blk*BLOCK_SIZE;
201                  s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
202
203          @block_stmts
204
205          tracker.StoreNewlines(lex.LF);
206                  postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)src_buffer, buffer_base, block_base, chars_avail, tracker);
207          matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
208          tracker.AdvanceBlock();
209      }
210      matcher.StreamScan(chars_avail);
211      matcher.Advance_buffer();
212      PERF_SEC_END(parser_timer, chars_avail);
213
214          memmove(src_buffer, &src_buffer[SEGMENT_SIZE], LOOKAHEAD_SIZE); // CopyBack Trailing Padding
215
216          // memmove(src_base, &src_buf[SEGMENT_SIZE-COPYBACK_SIZE], COPYBACK_SIZE); // Symbol Table CopyBack
217          chars_read = fread(&src_buffer[LOOKAHEAD_SIZE], 1, SEGMENT_SIZE, infile) + LOOKAHEAD_SIZE;
218          chars_avail = chars_read;
219          if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
220          buffer_pos += chars_avail;
221          buffer_base = buffer_pos;
222    }
223
224    //////////////////////////////////////////////////////////////////////////////////////////
225    // Final Partial Segment
226    //////////////////////////////////////////////////////////////////////////////////////////
227    PERF_SEC_START(parser_timer);
228
229    block_pos = 0;
230    int remaining = chars_avail;
231
232    /* Full Blocks */
233    while (remaining >= BLOCK_SIZE) {
234          block_base = block_pos;
235                  s2p_do_block((BytePack *) &src_buffer[block_pos], basis_bits);
236          @block_stmts
237          tracker.StoreNewlines(lex.LF);
238                  postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)src_buffer, buffer_base, block_base, chars_avail, tracker);
239                  matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
240          tracker.AdvanceBlock();
241          block_pos += BLOCK_SIZE;
242          remaining -= BLOCK_SIZE;
243    }
244    block_base = block_pos;
245
246    /* Partial Block or Any Carry */
247    if (remaining > 0 || @any_carry) {
248          EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
249                  s2p_do_final_block((BytePack *) &src_buffer[block_pos], basis_bits, EOF_mask);
250          @final_block_stmts
251          tracker.StoreNewlines(lex.LF);
252                  postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)src_buffer, buffer_base, block_base, chars_avail, tracker);
253          matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
254          tracker.AdvanceBlock();
255
256    }
257
258    buffer_pos += chars_avail;
259    buffer_base = buffer_pos;
260
261    matcher.StreamScan(chars_avail);
262    matcher.Advance_buffer();
263
264    if (matcher.depth != 0) {
265      fprintf(stderr, "tag matching error (depth %i) at position %i\n", matcher.depth, buffer_base);
266      exit(-1);
267    }
268        PERF_SEC_END(parser_timer, chars_avail);
269}
270
Note: See TracBrowser for help on using the repository browser.