source: proto/parabix2/pablo_template.cpp @ 2154

Last change on this file since 2154 was 2154, checked in by ksherdy, 7 years ago

Minor edit.

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