source: proto/SymbolTable/symtab_ls_template.cpp @ 4740

Last change on this file since 4740 was 1792, checked in by vla24, 7 years ago

Fixed macro names. I got L1 and L2 mixed up

File size: 9.2 KB
Line 
1#include "../common_definitions.h"
2#include <ls_symbol_table.h>
3
4#include "../symtab_common_functions.h"
5#include "../xmlwf_common_functions.h"
6
7#ifdef BUFFER_PROFILING
8        BOM_Table * parser_timer;
9
10#elif CODE_CLOCKER
11        #define NUM_EVENTS 1
12        //      int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
13#ifdef L2_PERF
14        int Events[NUM_EVENTS] = {PAPI_L2_DCM};
15#elif L1_PERF
16        int Events[NUM_EVENTS] = {PAPI_L1_DCM};
17#else
18        int Events[NUM_EVENTS] = {PAPI_BR_MSP};
19#endif
20        int cal_size = 20;
21        CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
22#else
23        void * parser_timer;
24#endif
25
26int block_base=0;
27int buffer_base=0;
28int buffer_last;
29
30TagMatcher matcher;
31
32queue <size_t> elem_starts_buf;
33queue <size_t> elem_ends_buf;
34LSSymbolTable ls_symbol_table;
35
36static inline void postprocess_do_block(Lex & lex, CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Check_streams & check_streams, Tag_Callouts & tag_Callouts, int chars_avail);
37void do_process(FILE *infile, FILE *outfile);
38
39static inline void do_symbol_table_lookup();
40
41int main(int argc, char * argv[]) {
42    char * infilename, * outfilename;
43    FILE *infile, *outfile;
44
45    getFilenames(argc, argv, infilename, outfilename);
46    openInputOutputFiles(infilename, outfilename,
47                         infile, outfile);
48
49//      PERF_SEC_BIND(1);
50
51    PERF_SEC_INIT(parser_timer);
52
53    // store symbols form text to Symbol Table
54    do_process(infile, outfile);
55
56    PERF_SEC_DUMP(parser_timer);
57
58    PERF_SEC_DESTROY(parser_timer);
59
60    fclose(infile);
61    fclose(outfile);
62
63#if PRINT_SYMBOL_DISTRIBUTION
64    print_GIDS(ls_symbol_table);
65#endif
66    ls_symbol_table.clear();
67    return(0);
68}
69
70static inline int ElemStrt_check(int pos) {
71        elem_starts_buf.push(buffer_base + pos);
72        return 0;
73}
74
75static inline int ElemEnd_check(int pos) {
76        elem_ends_buf.push(buffer_base + pos);
77        return 0;
78}
79
80static inline void do_symbol_table_lookup()
81{
82    while( !elem_starts_buf.empty() && !elem_ends_buf.empty() )
83    {
84        int start = elem_starts_buf.front();
85        int end = elem_ends_buf.front();
86        elem_starts_buf.pop();
87        elem_ends_buf.pop();
88        int length = end - start;
89
90        //lookup or insert to symbol table
91#if DEBUG
92        char* symbol = new char[length+1];
93        strncpy ( symbol, source + start - buffer_base, length );
94        symbol[length] ='\0';
95        printf ("start: %i[%i] | end: %i[%i] | length: %i | symbol: %s\n", start, start-buffer_base, end, end-buffer_base, length, symbol );
96
97        delete symbol; symbol = 0;
98#endif
99
100        ls_symbol_table.put((unsigned char*)source + start - buffer_base, length);
101
102    }
103}
104
105static inline void postprocess_do_block(Lex & lex, CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Check_streams & check_streams, Tag_Callouts & tag_Callouts, int chars_avail){
106
107    tracker.StoreNewlines(lex.LF);
108
109    if ( bitblock_has_bit(tag_Callouts.ElemName_starts))
110    {
111        BitBlockForwardIterator iter_length_grouping_starts(&tag_Callouts.ElemName_starts);
112        validate_block(iter_length_grouping_starts, block_base, ElemStrt_check);
113    }
114
115    if ( bitblock_has_bit(tag_Callouts.ElemName_ends) )
116    {
117        BitBlockForwardIterator iter_length_grouping_ends(&tag_Callouts.ElemName_ends);
118        validate_block(iter_length_grouping_ends, block_base, ElemEnd_check);
119    }
120
121    do_symbol_table_lookup();
122
123
124    if (bitblock_has_bit(simd_or(check_streams.non_ascii_name_starts, check_streams.non_ascii_names))) {
125        BitBlockForwardIterator iter_NameStrt_check(&check_streams.non_ascii_name_starts);
126        validate_block(iter_NameStrt_check, block_base, NameStrt_check);
127        BitBlockForwardIterator iter_Name_check(&check_streams.non_ascii_names);
128        validate_block(iter_Name_check, block_base, Name_check);
129    }
130    if (bitblock_has_bit(ctCDPI_Callouts.PI_name_starts)){
131        BitBlockForwardIterator iter_PI_name_starts(&(ctCDPI_Callouts.PI_name_starts));
132        validate_block(iter_PI_name_starts, block_base, buffer_base, PIName_check);
133    }
134    if (bitblock_has_bit(ctCDPI_Callouts.CD_starts)){
135        BitBlockForwardIterator iter_CD_check(&ctCDPI_Callouts.CD_starts);
136        validate_block(iter_CD_check, block_base, CD_check);
137    }
138    if(bitblock_has_bit(ref_Callouts.GenRef_starts)){
139        BitBlockForwardIterator iter_GenRef_check(&ref_Callouts.GenRef_starts);
140        validate_block(iter_GenRef_check, block_base, GenRef_check);
141    }
142    if(bitblock_has_bit(ref_Callouts.DecRef_starts)){
143        BitBlockForwardIterator iter_DecRef_check(&ref_Callouts.DecRef_starts);
144        validate_block(iter_DecRef_check, block_base, DecRef_check);
145    }
146    if(bitblock_has_bit(ref_Callouts.HexRef_starts)){
147        BitBlockForwardIterator iter_HexRef_check(&ref_Callouts.HexRef_starts);
148        validate_block(iter_HexRef_check, block_base, HexRef_check);
149    }
150    if(bitblock_has_bit(check_streams.att_refs)){
151        BitBlockForwardIterator iter_AttRef_check(&check_streams.att_refs);
152        validate_block(iter_AttRef_check, block_base, AttRef_check);
153    }
154
155    if(error_tracker.Has_Noted_Error()){
156        int error_line, error_column;
157        tracker.get_Line_and_Column(error_tracker.Noted_Pos_In_Block(), error_line, error_column);
158        ReportError(error_tracker.Noted_Error_Msg(), error_line, error_column);
159        exit(-1);
160    }
161
162    matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
163    tracker.AdvanceBlock();
164}
165
166void do_process(FILE *infile, FILE *outfile) {
167
168@decl
169
170  int buf_pos = 0;
171  int block_pos = 0;
172  int errpos = 0;
173  int chars_avail = 0;
174  int check_pos = 0;
175  int chars_read = 0;
176  BytePack buf[(BUFFER_SIZE+BLOCK_SIZE+OVERLAP_BUFSIZE*2)/sizeof(SIMD_type)];
177
178  char * srcbuf = ((char *) buf) + OVERLAP_BUFSIZE;
179  buffer_base = buf_pos;
180  source = srcbuf;
181  chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE + OVERLAP_BUFSIZE, infile);
182  chars_avail = chars_read;
183  if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
184
185  matcher.setSrc(srcbuf);
186
187  if(chars_read<4){
188    fprintf(stderr,"File is too short. Not well formed.\n");
189    exit(-1);
190  }
191
192  Entity_Info * e = new Entity_Info;
193  e->AnalyzeSignature((unsigned char *)srcbuf);
194
195  if (e->code_unit_base == ASCII) {
196
197    XML_Decl_Parser<ASCII> decl_parser((unsigned char *)srcbuf);
198
199    decl_parser.ReadXMLInfo(*e);
200
201    if (e->code_unit_size != SingleByte || (e->has_encoding_decl && (!at_UTF_8(e->encoding)))){
202        fprintf(stderr,"Sorry, this xmlwf demo only works for UTF-8.\n");
203        exit(-1);
204    }
205  }
206  else {
207    fprintf(stderr,"Sorry, this xmlwf demo does not process EBCDIC.\n");
208        exit(-1);
209  }
210
211  if (e->content_start != 0) {
212        memmove(&srcbuf[0], &srcbuf[e->content_start], chars_read - e->content_start);
213        buf_pos = e->content_start;
214        buffer_base = buf_pos;
215        if (chars_avail == BUFFER_SIZE) {
216                chars_read = chars_read - e->content_start +
217                             fread(&srcbuf[chars_read-e->content_start], 1, e->content_start, infile);
218                chars_avail = chars_read;
219                if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
220        }
221        else {
222          chars_read -=e->content_start;
223          chars_avail -=e->content_start;
224        }
225  }
226
227@stream_stmts
228/* Full Buffers */
229    while (chars_avail == BUFFER_SIZE) {
230      PERF_SEC_START(parser_timer);
231
232      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
233          block_base = blk*BLOCK_SIZE;
234          s2p_do_block((BytePack *) &srcbuf[block_base], basis_bits);
235          @block_stmts
236          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, chars_avail);
237      }
238      matcher.StreamScan(chars_avail);
239      matcher.Advance_buffer();
240      tracker.Advance_buffer();
241#ifndef CACHE_PERF
242    PERF_SEC_END(parser_timer, chars_avail);
243#else
244    PERF_SEC_END(parser_timer, 1);
245#endif
246
247      int bytes_left = chars_read - chars_avail;
248      memmove(buf, &srcbuf[BUFFER_SIZE - OVERLAP_BUFSIZE], bytes_left + OVERLAP_BUFSIZE);
249      chars_read = fread(&srcbuf[bytes_left],1, BUFFER_SIZE + OVERLAP_BUFSIZE - bytes_left, infile) + bytes_left;
250      chars_avail = chars_read;
251      if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
252      buf_pos += chars_avail;
253      if (!elem_starts_buf.size() == elem_ends_buf.size())
254      {
255          int start = elem_starts_buf.front();
256          start = (start - buffer_base) - BUFFER_SIZE + buf_pos;
257          elem_starts_buf.pop();
258          elem_starts_buf.push(start);
259      }
260      buffer_base = buf_pos;
261    }
262/* Final Partial Buffer */
263    PERF_SEC_START(parser_timer);
264
265    block_pos = 0;
266    int remaining = chars_avail;
267/* Full Blocks */
268    while (remaining >= BLOCK_SIZE) {
269          block_base = block_pos;
270          s2p_do_block((BytePack *) &srcbuf[block_pos], basis_bits);
271          @block_stmts
272          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, chars_avail);
273          block_pos += BLOCK_SIZE;
274          remaining -= BLOCK_SIZE;
275    }
276    block_base = block_pos;
277    if (remaining > 0 || @any_carry) {
278          EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
279          s2p_do_final_block((BytePack *) &srcbuf[block_pos], basis_bits, EOF_mask);
280          @final_block_stmts
281          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, chars_avail);
282    }
283    buf_pos += chars_avail;
284    buffer_base = buf_pos;
285
286    matcher.StreamScan(chars_avail);
287    matcher.Advance_buffer();
288    tracker.Advance_buffer();
289
290    ls_symbol_table.bind();
291    ls_symbol_table.finalize();
292#ifndef CACHE_PERF
293    PERF_SEC_END(parser_timer, chars_avail);
294#else
295    PERF_SEC_END(parser_timer, 1);
296#endif
297    if (matcher.depth != 0) {
298      fprintf(stderr, "tag matching error (depth %i) at position %i\n", matcher.depth, buffer_base);
299      exit(-1);
300    }
301}
Note: See TracBrowser for help on using the repository browser.