source: proto/Xerces/pablo_template.cpp @ 1482

Last change on this file since 1482 was 1475, checked in by ksherdy, 8 years ago

Centralized typedefs.

File size: 13.7 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 "../lib/lib_simd.h"
7
8#define BLOCK_SIZE (sizeof(SIMD_type) * 8)
9#define SEGMENT_BLOCKS 12
10#define BUFFER_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
11#define OVERLAP_BUFSIZE (sizeof(SIMD_type))
12
13#include "../lib/carryQ.h"
14#include "xmldecl.h"
15#include "namechars.h"
16#include "../lib/perflib/perfsec.h"
17#include "../lib/s2p.h"
18#include "TagMatcher.h"
19#include "LineColTracker.h"
20#include "ErrorUtil.h"
21#include "ErrorTracker.h"
22#include "XMLTestSuiteError.h"
23
24#ifdef BUFFER_PROFILING
25        BOM_Table * parser_timer;
26
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        //int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
32        int cal_size = 20;
33        CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
34#else
35        void * parser_timer;
36#endif
37
38int block_base=0;
39int buffer_base=0;
40int buffer_last;
41char * source;
42
43//LineColTracker tracker;
44//TagMatcher matcher;
45ErrorTracker error_tracker;
46BitBlock EOF_mask = simd_const_1(1);
47
48//      static inline int StreamScanToFirst(ScanBlock * stream, int blk_count, int ProcessPos(int), int * error_pos_in_block)
49static inline int StreamScan(ScanBlock * stream, int blk_count, int ProcessPos(int), int * error_pos_in_block) {
50
51        int blk;
52        int block_pos = 0;
53        int pos;
54
55        for (blk = 0; blk < blk_count; blk++) {
56                ScanBlock s = stream[blk];
57                while(s) {
58                        pos = (cfzl(s) + block_pos);
59                        int code = (ProcessPos(pos));
60                        if (code) {
61                                *error_pos_in_block = pos;
62                                return code; // error code
63                        }
64                        s = s & (s-1);  // clear rightmost bit.
65                }
66                block_pos += 8 * sizeof(ScanBlock);
67        }
68        return 0;
69}
70
71static inline int NameStrt_check(int pos) {
72        int block_pos = block_base + pos;
73        if(XML_10_UTF8_NameStrt_bytes((unsigned char*)&source[block_pos]) == 0){
74              return XMLTestSuiteError::NAME_START;
75        }
76        return 0;
77}
78
79static inline int Name_check(int pos) {
80        int block_pos = block_base + pos;
81        if(XML_10_UTF8_NameChar_bytes((unsigned char*)&source[block_pos]) == 0){
82                  return XMLTestSuiteError::NAME;
83        }
84        return 0;
85}
86
87static inline int PIName_check(int pos) {
88        int block_pos = block_base + pos;
89        int file_pos = block_pos+buffer_base;
90        if (at_XxMmLll<ASCII>((unsigned char*)&source[block_pos]) && (source[block_pos+3]=='?' || source[block_pos+3]<= ' ')) {
91              // "<?xml" legal at start of file.
92              if (!((file_pos == 2) && at_XmlDecl_start<ASCII>((unsigned char*)&source[0]))) {
93                  return XMLTestSuiteError::XMLPINAME;
94              }
95        }
96        return 0;
97}
98
99static inline int CD_check(int pos) {
100        int block_pos = block_base + pos;
101        if (!at_CDATA1<ASCII>((unsigned char*)&source[block_pos])){
102                  return XMLTestSuiteError::CDATA;
103        }
104        return 0;
105}
106
107static inline int GenRef_check(int pos) {
108        int block_pos = block_base + pos;
109        unsigned char* s = (unsigned char*)&source[block_pos];
110        if (!(at_Ref_gt<ASCII>(s)||at_Ref_lt<ASCII>(s)||at_Ref_amp<ASCII>(s)||at_Ref_quot<ASCII>(s)||at_Ref_apos<ASCII>(s))){
111              return XMLTestSuiteError::UNDEFREF;
112        }
113        return 0;
114}
115
116static inline int HexRef_check(int pos) {
117        int block_pos = block_base + pos;
118        unsigned char* s = (unsigned char*)&source[block_pos];
119        int ch_val = 0;
120        while(at_HexDigit<ASCII>(s)){
121          ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
122          if (ch_val> 0x10FFFF ){
123                return XMLTestSuiteError::CHARREF;
124          }
125          s++;
126        }
127        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
128          return XMLTestSuiteError::CHARREF;
129        }
130        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
131          return XMLTestSuiteError::XML10CHARREF;
132        }
133        return 0;
134}
135
136static inline int DecRef_check(int pos) {
137        int block_pos = block_base + pos;
138        unsigned char* s = (unsigned char*)&source[block_pos];
139        int ch_val = 0;
140        while(at_HexDigit<ASCII>(s)){
141          ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
142          if (ch_val> 0x10FFFF ){
143                        return XMLTestSuiteError::CHARREF;
144          }
145          s++;
146        }
147        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
148                  return XMLTestSuiteError::CHARREF;
149        }
150        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
151                  return XMLTestSuiteError::XML10CHARREF;
152        }
153        return 0;
154}
155
156static inline int AttRef_check(int pos) {
157        int block_pos = block_base + pos;
158        unsigned char* s = (unsigned char*)&source[block_pos];
159        int ch_val = 0;
160        if(s[0]=='#'){
161          s++;
162          if(s[0]=='x' || s[0]=='X'){
163            s++;
164            while(at_HexDigit<ASCII>(s)){
165              ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
166              s++;
167            }
168          }
169          else{
170            while(at_HexDigit<ASCII>(s)){
171              ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
172              s++;
173            }
174          }
175          if (ch_val==60){
176            return XMLTestSuiteError::ATTREF;
177          }
178        }
179        else if(at_Ref_lt<ASCII>(s)){
180          return XMLTestSuiteError::ATTREF;
181        }
182        return 0;
183}
184
185
186
187@global
188
189static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
190  s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
191        basis_bits.bit_0, basis_bits.bit_1, basis_bits.bit_2, basis_bits.bit_3, basis_bits.bit_4, basis_bits.bit_5, basis_bits.bit_6, basis_bits.bit_7);
192}
193
194static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask) {
195  s2p_do_block(U8, basis_bits);
196  basis_bits.bit_0 = simd_and(basis_bits.bit_0, EOF_mask);
197  basis_bits.bit_1 = simd_and(basis_bits.bit_1, EOF_mask);
198  basis_bits.bit_2 = simd_and(basis_bits.bit_2, EOF_mask);
199  basis_bits.bit_3 = simd_and(basis_bits.bit_3, EOF_mask);
200  basis_bits.bit_4 = simd_and(basis_bits.bit_4, EOF_mask);
201  basis_bits.bit_5 = simd_and(basis_bits.bit_5, EOF_mask);
202  basis_bits.bit_6 = simd_and(basis_bits.bit_6, EOF_mask);
203  basis_bits.bit_7 = simd_and(basis_bits.bit_7, EOF_mask);
204}
205
206/*
207static inline void postprocess_do_block(Lex & lex, CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Check_streams & check_streams, int chars_avail){
208            tracker.StoreNewlines(lex.LF);
209            int rv, error_pos_in_block, error_line, error_column;
210
211                if (bitblock_has_bit(simd_or(check_streams.non_ascii_name_starts, check_streams.non_ascii_names))) {
212                  rv = StreamScan((ScanBlock *) &check_streams.non_ascii_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), NameStrt_check, &error_pos_in_block);
213                  if (rv) {
214                          tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
215                          ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
216                          exit(-1);
217                  }
218
219                  rv = StreamScan((ScanBlock *) &check_streams.non_ascii_names, sizeof(BitBlock)/sizeof(ScanBlock), Name_check, &error_pos_in_block);
220                  if (rv) {
221                          tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
222                          ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
223                          exit(-1);
224                  }
225                }
226
227                if (bitblock_has_bit(ctCDPI_Callouts.PI_name_starts)){
228                  rv = StreamScan((ScanBlock *) &ctCDPI_Callouts.PI_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), PIName_check, &error_pos_in_block);
229                  if (rv) {
230                          tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
231                          ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
232                          exit(-1);
233                  }
234                }
235
236                if (bitblock_has_bit(ctCDPI_Callouts.CD_starts)){
237                  rv = StreamScan((ScanBlock *) &ctCDPI_Callouts.CD_starts, sizeof(BitBlock)/sizeof(ScanBlock), CD_check, &error_pos_in_block);
238                  if (rv) {
239                          tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
240                          ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
241                          exit(-1);
242                  }
243                }
244
245                if (bitblock_has_bit(ref_Callouts.GenRef_starts)){
246                  rv = StreamScan((ScanBlock *) &ref_Callouts.GenRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), GenRef_check, &error_pos_in_block);
247                  if (rv) {
248                          tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
249                          ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
250                          exit(-1);
251                  }
252                }
253
254                if (bitblock_has_bit(ref_Callouts.DecRef_starts)){
255                  rv = StreamScan((ScanBlock *) &ref_Callouts.DecRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), DecRef_check, &error_pos_in_block);
256                  if (rv) {
257                          tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
258                          ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
259                          exit(-1);
260                  }
261                }
262
263                if (bitblock_has_bit(ref_Callouts.HexRef_starts)){
264                  rv = StreamScan((ScanBlock *) &ref_Callouts.HexRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), HexRef_check, &error_pos_in_block);
265                  if (rv) {
266                          tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
267                          ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
268                          exit(-1);
269                  }
270                }
271
272                if (bitblock_has_bit(check_streams.att_refs)){
273                  rv = StreamScan((ScanBlock *) &check_streams.att_refs, sizeof(BitBlock)/sizeof(ScanBlock), AttRef_check, &error_pos_in_block);
274                  if (rv) {
275                          tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
276                          ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
277                          exit(-1);
278                  }
279                }
280
281                if(error_tracker.Has_Noted_Error()){
282                        tracker.get_Line_and_Column(error_tracker.Noted_Pos_In_Block(), error_line, error_column);
283                        ReportError(error_tracker.Noted_Error_Msg(), error_line, error_column);
284                        exit(-1);
285                }
286
287                matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
288                tracker.AdvanceBlock();
289}
290*/
291
292void do_process(FILE *infile, FILE *outfile) {
293
294@decl
295
296  int buf_pos = 0;
297  int block_pos = 0;
298  int errpos = 0;
299  int chars_avail = 0;
300  int check_pos = 0;
301  int chars_read = 0;
302  BytePack buf[(BUFFER_SIZE+BLOCK_SIZE+OVERLAP_BUFSIZE*2)/sizeof(SIMD_type)];
303
304  char * srcbuf = ((char *) buf) + OVERLAP_BUFSIZE;
305  buffer_base = buf_pos;
306  source = srcbuf;
307
308  chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE + OVERLAP_BUFSIZE, infile);
309  chars_avail = chars_read;
310  if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
311
312  //matcher.setSrc(srcbuf);
313
314  if(chars_read<4){
315    fprintf(stderr,"File is too short. Not well formed.\n");
316    exit(-1);
317  }
318
319  Entity_Info * e = new Entity_Info;
320  e->AnalyzeSignature((unsigned char *)srcbuf);
321
322  if (e->code_unit_base == ASCII) {
323
324    XML_Decl_Parser<ASCII> decl_parser((unsigned char *)srcbuf);
325
326    decl_parser.ReadXMLInfo(*e);
327
328    if (e->code_unit_size != SingleByte || (e->has_encoding_decl && (!at_UTF_8(e->encoding)))){
329        fprintf(stderr,"Sorry, this xmlwf demo only works for UTF-8.\n");
330        exit(-1);
331    }
332  }
333  else {
334    fprintf(stderr,"Sorry, this xmlwf demo does not process EBCDIC.\n");
335        exit(-1);
336  }
337
338  if (e->content_start != 0) {
339        memmove(&srcbuf[0], &srcbuf[e->content_start], chars_read - e->content_start);
340        buf_pos = e->content_start;
341        if (chars_avail == BUFFER_SIZE) {
342                chars_read = chars_read - e->content_start +
343                             fread(&srcbuf[chars_read-e->content_start], 1, e->content_start, infile);
344                chars_avail = chars_read;
345                if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
346        }
347        else {
348          chars_read -=e->content_start;
349          chars_avail -=e->content_start;
350        }
351  }
352
353@stream_stmts
354
355/* Full Buffers */
356
357    while (chars_avail == BUFFER_SIZE) {
358      PERF_SEC_START(parser_timer);
359      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
360          block_base = blk*BLOCK_SIZE;
361          s2p_do_block((BytePack *) &srcbuf[block_base], basis_bits);
362          @block_stmts
363          //postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, chars_avail);
364      }
365      //matcher.StreamScan(chars_avail);
366      //matcher.Advance_buffer();
367      //tracker.Advance_buffer();
368      PERF_SEC_END(parser_timer, chars_avail);
369           
370      int bytes_left = chars_read - chars_avail;
371      memmove(srcbuf, &srcbuf[BUFFER_SIZE], bytes_left);
372      chars_read = fread(&srcbuf[bytes_left],1, BUFFER_SIZE + OVERLAP_BUFSIZE - bytes_left, infile) + bytes_left;
373      chars_avail = chars_read;
374      if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
375      buf_pos += chars_avail;
376      buffer_base = buf_pos;
377    }
378/* Final Partial Buffer */
379    PERF_SEC_START(parser_timer);
380
381    block_pos = 0;
382    int remaining = chars_avail;
383/* Full Blocks */
384    while (remaining >= BLOCK_SIZE) {
385          block_base = block_pos;
386          s2p_do_block((BytePack *) &srcbuf[block_pos], basis_bits);
387          @block_stmts
388          //postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, chars_avail);
389          block_pos += BLOCK_SIZE;
390          remaining -= BLOCK_SIZE;
391    }
392    block_base = block_pos;
393    if (remaining > 0 || @any_carry) {
394          EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-remaining));
395          s2p_do_final_block((BytePack *) &srcbuf[block_pos], basis_bits, EOF_mask);
396          @final_block_stmts
397          //postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, chars_avail);
398    }
399    buf_pos += chars_avail;
400    buffer_base = buf_pos;
401
402    /*
403    matcher.StreamScan(chars_avail);
404    matcher.Advance_buffer();
405    tracker.Advance_buffer();
406        */
407
408    PERF_SEC_END(parser_timer, chars_avail);
409
410    /*
411    if (matcher.depth != 0) {
412      fprintf(stderr, "tag matching error (depth %i) at position %i\n", matcher.depth, buffer_base);
413      exit(-1);
414    }
415    */
416}
417
418
419
420int
421main(int argc, char * argv[]) {
422        char * infilename, * outfilename;
423        FILE *infile, *outfile;
424        struct stat fileinfo;
425
426        if (argc < 2) {
427                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
428                exit(-1);
429        }
430
431        infilename = argv[1];
432        stat(infilename, &fileinfo);
433        infile = fopen(infilename, "rb");
434        if (!infile) {
435                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
436                exit(-1);
437        }
438
439        if (argc < 3) outfile = stdout;
440        else {
441                outfilename = argv[2];
442                outfile = fopen(outfilename, "wb");
443                if (!outfile) {
444                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
445                        exit(-1);
446                }
447        }
448
449//      PERF_SEC_BIND(1);
450
451        PERF_SEC_INIT(parser_timer);
452
453        do_process(infile, outfile);
454
455        PERF_SEC_DUMP(parser_timer);
456
457        PERF_SEC_DESTROY(parser_timer);
458
459        fclose(infile);
460        fclose(outfile);
461        return(0);
462}
Note: See TracBrowser for help on using the repository browser.