source: proto/parabix2/template.c @ 607

Last change on this file since 607 was 607, checked in by lindanl, 9 years ago

Check for encoding. Only process UTF-8.

File size: 18.4 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#include "../lib/block_carry.h"
8
9       
10#define BLOCK_SIZE 128
11#define BUFFER_SIZE (BLOCK_SIZE * 25)
12#define OVERLAP_BUFSIZE 16
13
14typedef long ScanBlock;
15typedef SIMD_type BytePack;
16typedef SIMD_type BitBlock;
17
18#include "xmldecl.h"
19#include "xml_error.c"
20#include "xmldecl.c"
21#include "namechars.h"
22
23#include "../lib/perflib/perfsec.h"
24
25#include "tag_matcher.cpp"
26
27#ifdef BUFFER_PROFILING
28        BOM_Table * parser_timer;
29
30#elif CODE_CLOCKER
31        #define NUM_EVENTS 1
32        int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
33        //int Events[NUM_EVENTS] = {PAPI_L2_DCM};
34        //int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
35        int cal_size = 20;
36        CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
37#else
38        void * parser_timer;
39#endif
40
41int block_base=0;
42int buffer_base=0;
43int buffer_last;
44char * source;
45
46
47static inline int StreamScan(ScanBlock * stream, int blk_count, int ProcessPos(int)) {
48        int blk;
49        int block_pos = 0;
50
51        for (blk = 0; blk < blk_count; blk++) {
52                ScanBlock s = stream[blk];
53                while(s) {
54                        int code = (ProcessPos(cfzl(s) + block_pos));
55                        if (code) return code;
56                        s = s & (s-1);  // clear rightmost bit.
57                }
58                block_pos += 8 * sizeof(ScanBlock);
59        }
60        return 0;
61} 
62
63
64
65inline bool bit_test(unsigned char * bit_Map, int codepoint) {
66        return (bit_Map[codepoint/8] >> (7 - codepoint % 8)) & 1;
67}
68
69bool is_XML10_NameStrt_codepoint(int codepoint) {
70        switch (codepoint >> 12) {
71                case 0: return bit_test(NameStrt_XML10_0000_11FF, codepoint);
72                case 1: if (codepoint <= 0x11FF)
73                                return bit_test(NameStrt_XML10_0000_11FF, codepoint);
74                        else if (codepoint < 0x1E00) return false;
75                        else return bit_test(NameStrt_XML10_1E00_1FFF, codepoint & 0x1FF);
76                case 2: if (codepoint > 0x2182) return false;
77                        else return bit_test(NameStrt_XML10_2000_21FF, codepoint & 0x1FF);
78                case 3: if (codepoint > 0x312C) return false;
79                        else return bit_test(NameStrt_XML10_3000_31FF, codepoint & 0x1FF);
80                case 4: return codepoint >= 0x4E00;
81                case 5: case 6: case 7: case 8: return true;
82                case 9: return codepoint <= 0x9FA5;
83                case 0xA: return codepoint >= 0xAC00;
84                case 0xB: case 0xC: return true;
85                case 0xD: return codepoint <= 0xD7A3;
86                default: return false;
87        }
88}
89
90bool is_XML10_NameChar_codepoint(int codepoint) {
91        switch (codepoint >> 12) {
92                case 0: return bit_test(NameChar_XML10_0000_11FF, codepoint);
93                case 1: if (codepoint <= 0x11FF)
94                                return bit_test(NameChar_XML10_0000_11FF, codepoint);
95                        else if (codepoint < 0x1E00) return false;
96                        else return bit_test(NameStrt_XML10_1E00_1FFF, codepoint & 0x1FF);
97                case 2: if (codepoint > 0x2182) return false;
98                        else return bit_test(NameChar_XML10_2000_21FF, codepoint & 0x1FF);
99                case 3: if (codepoint > 0x312C) return false;
100                        else return bit_test(NameChar_XML10_3000_31FF, codepoint & 0x1FF);
101                case 4: return codepoint >= 0x4E00;
102                case 5: case 6: case 7: case 8: return true;
103                case 9: return codepoint <= 0x9FA5;
104                case 0xA:       return codepoint >= 0xAC00;
105                case 0xB: case 0xC: return true;
106                case 0xD: return codepoint <= 0xD7A3;
107                default: return false;
108        }
109}
110
111inline int XML_10_UTF8_NameStrt_bytes (unsigned char bytes[]) {
112        if (bytes[0] <= 0x7F) {
113                if (bit_test(NameStrt_XML10_0000_11FF, (int) bytes[0])) return 1;
114                else return 0;
115        }
116        else if (bytes[0] <= 0xDF) {
117                int codepoint = ((bytes[0] & 0x3F) << 6) | (bytes[1] & 0x3F);
118                if (bit_test(NameStrt_XML10_0000_11FF, codepoint)) return 2;
119                else return 0;
120        }
121        else if (bytes[0] <= 0xEF) {
122                int codepoint = ((bytes[0] & 0x0F) << 12)| ((bytes[1] & 0x3F) << 6) | (bytes[2] & 0x3F);
123                return is_XML10_NameStrt_codepoint(codepoint) ? 3 : 0;
124        }
125        else return 0;
126}
127
128inline int XML_10_UTF8_NameChar_bytes (unsigned char bytes[]) {
129        if (bytes[0] <= 0x7F) {
130                if (bit_test(NameChar_XML10_0000_11FF, (int) bytes[0])) return 1;
131                else return 0;
132        }
133        else if (bytes[0] <= 0xDF) {
134                int codepoint = ((bytes[0] & 0x3F) << 6) | (bytes[1] & 0x3F);
135                if (bit_test(NameChar_XML10_0000_11FF, codepoint)) return 2;
136                else return 0;
137        }
138        else if (bytes[0] <= 0xEF) {
139                int codepoint = ((bytes[0] & 0x0F) << 12)| ((bytes[1] & 0x3F) << 6) | (bytes[2] & 0x3F);
140                return is_XML10_NameChar_codepoint(codepoint) ? 3 : 0;
141        }
142        else return 0;
143}
144
145
146static inline int NameStrt_check(int pos) {
147        int block_pos = block_base + pos;
148        if(XML_10_UTF8_NameStrt_bytes((unsigned char*)&source[block_pos]) == 0){
149              fprintf(stderr, "name start error found at position %i\n",block_pos+buffer_base);
150              exit(-1);
151        }
152        return 0;
153}
154
155static inline int Name_check(int pos) {
156        int block_pos = block_base + pos;
157        if(XML_10_UTF8_NameChar_bytes((unsigned char*)&source[block_pos]) == 0){
158              fprintf(stderr, "name error found at position %i\n",block_pos+buffer_base);
159              exit(-1);
160        }
161        return 0;
162}
163
164static inline int PIName_check(int pos) {
165        int block_pos = block_base + pos;
166        int file_pos = block_pos+buffer_base; 
167        if (at_XxMmLll<ASCII>((unsigned char*)&source[block_pos]) && (source[block_pos+3]=='?' || source[block_pos+3]<= ' ')) {
168              // "<?xml" legal at start of file.
169              if ((file_pos == 2) && at_XmlDecl_start<ASCII>((unsigned char*)&source[0])) return 0;
170              fprintf(stderr, "[Xx][Mm][Ll] illegal as PI name at position %i\n",file_pos);
171              exit(-1);
172        }
173        return 0;
174}
175
176static inline int CD_check(int pos) {
177        int block_pos = block_base + pos;
178        if (!at_CDATA1<ASCII>((unsigned char*)&source[block_pos])){
179              fprintf(stderr, "CDATA error found at position %i\n",block_pos+buffer_base);
180              exit(-1);
181        }
182        return 0;
183}
184
185static inline int GenRef_check(int pos) {
186        int block_pos = block_base + pos;
187        unsigned char* s = (unsigned char*)&source[block_pos];
188        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))){
189              fprintf(stderr, "Undefined Reference found at position %i\n",block_pos+buffer_base);
190              exit(-1);
191        }
192        return 0;
193}
194
195static inline int HexRef_check(int pos) {
196        int block_pos = block_base + pos;
197        unsigned char* s = (unsigned char*)&source[block_pos];
198        int ch_val = 0;
199        while(at_HexDigit<ASCII>(s)){
200          ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
201          if (ch_val> 0x10FFFF ){
202            fprintf(stderr, "Illegal character reference found at position %i\n",block_pos+buffer_base);
203            exit(-1);
204          }
205          s++;
206        }
207        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
208          fprintf(stderr, "Illegal character reference found at position %i\n",block_pos+buffer_base);
209          exit(-1);
210        }
211        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
212          fprintf(stderr, "Illegal XML 1.0 character reference found at position %i\n",block_pos+buffer_base);
213          exit(-1);
214        }
215        return 0;
216}
217
218static inline int DecRef_check(int pos) {
219        int block_pos = block_base + pos;
220        unsigned char* s = (unsigned char*)&source[block_pos];
221        int ch_val = 0;
222        while(at_HexDigit<ASCII>(s)){
223          ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
224          if (ch_val> 0x10FFFF ){
225            fprintf(stderr, "Illegal character reference found at position %i\n",block_pos+buffer_base);
226            exit(-1);
227          }
228          s++;
229        }
230        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
231          fprintf(stderr, "Illegal character reference found at position %i\n",block_pos+buffer_base);
232          exit(-1);
233        }
234        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
235          fprintf(stderr, "Illegal XML 1.0 character reference found at position %i\n",block_pos+buffer_base);
236          exit(-1);
237        }
238        return 0;
239}
240
241static inline int AttRef_check(int pos) {
242        int block_pos = block_base + pos;
243        unsigned char* s = (unsigned char*)&source[block_pos];
244        int ch_val = 0;
245        if(s[0]=='#'){
246          s++;
247          if(s[0]=='x' or s[0]=='X'){
248            s++;
249            while(at_HexDigit<ASCII>(s)){
250              ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
251              s++;
252            }
253          }
254          else{     
255            while(at_HexDigit<ASCII>(s)){
256              ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
257              s++;
258            }
259          }
260          if (ch_val==60){
261            fprintf(stderr, "Attribute values contain '<' characters after reference expansion at position %i\n",block_pos+buffer_base);
262            exit(-1);
263          }       
264        }
265        else if(at_Ref_lt<ASCII>(s)){
266          fprintf(stderr, "Attribute values contain '<' characters after reference expansion at position %i\n",block_pos+buffer_base);
267          exit(-1);
268        }         
269        return 0;
270}
271
272#define s2p_step(s0,s1,hi_mask,shift,p0,p1)  \
273{ \
274BitBlock t0,t1; \
275t0= simd_pack_16_hh(s0,s1) ; \
276t1= simd_pack_16_ll(s0,s1) ; \
277p0= simd_if(hi_mask,t0,simd_srli_16(t1,shift) ) ; \
278p1= simd_if(hi_mask,simd_slli_16(t0,shift) ,t1) ; \
279} \
280
281#define s2p_bytepack(s0,s1,s2,s3,s4,s5,s6,s7,p0,p1,p2,p3,p4,p5,p6,p7)  \
282{BitBlock bit00224466_0,bit00224466_1,bit00224466_2,bit00224466_3; \
283BitBlock bit11335577_0,bit11335577_1,bit11335577_2,bit11335577_3; \
284BitBlock bit00004444_0,bit22226666_0,bit00004444_1,bit22226666_1; \
285BitBlock bit11115555_0,bit33337777_0,bit11115555_1,bit33337777_1; \
286s2p_step(s0,s1,simd_himask_2,1,bit00224466_0,bit11335577_0)  \
287s2p_step(s2,s3,simd_himask_2,1,bit00224466_1,bit11335577_1)  \
288s2p_step(s4,s5,simd_himask_2,1,bit00224466_2,bit11335577_2)  \
289s2p_step(s6,s7,simd_himask_2,1,bit00224466_3,bit11335577_3)  \
290s2p_step(bit00224466_0,bit00224466_1,simd_himask_4,2,bit00004444_0,bit22226666_0)  \
291s2p_step(bit00224466_2,bit00224466_3,simd_himask_4,2,bit00004444_1,bit22226666_1)  \
292s2p_step(bit11335577_0,bit11335577_1,simd_himask_4,2,bit11115555_0,bit33337777_0)  \
293s2p_step(bit11335577_2,bit11335577_3,simd_himask_4,2,bit11115555_1,bit33337777_1)  \
294s2p_step(bit00004444_0,bit00004444_1,simd_himask_8,4,p0,p4)  \
295s2p_step(bit11115555_0,bit11115555_1,simd_himask_8,4,p1,p5)  \
296s2p_step(bit22226666_0,bit22226666_1,simd_himask_8,4,p2,p6)  \
297s2p_step(bit33337777_0,bit33337777_1,simd_himask_8,4,p3,p7)  \
298} \
299
300#define p2s_step(p0,p1,hi_mask,shift,s0,s1)  \
301{ \
302BitBlock t0,t1; \
303t0= simd_if(hi_mask,p0,simd_srli_16(p1,shift) ) ; \
304t1= simd_if(hi_mask,simd_slli_16(p0,shift) ,p1) ; \
305s0= simd_mergeh_8(t0,t1) ; \
306s1= simd_mergel_8(t0,t1) ; \
307} \
308
309#define p2s_bytemerge(p0,p1,p2,p3,p4,p5,p6,p7,s0,s1,s2,s3,s4,s5,s6,s7)  \
310{ \
311BitBlock bit00004444_0,bit22226666_0,bit00004444_1,bit22226666_1; \
312BitBlock bit11115555_0,bit33337777_0,bit11115555_1,bit33337777_1; \
313BitBlock bit00224466_0,bit00224466_1,bit00224466_2,bit00224466_3; \
314BitBlock bit11335577_0,bit11335577_1,bit11335577_2,bit11335577_3; \
315p2s_step(p0,p4,simd_himask_8,4,bit00004444_0,bit00004444_1)  \
316p2s_step(p1,p5,simd_himask_8,4,bit11115555_0,bit11115555_1)  \
317p2s_step(p2,p6,simd_himask_8,4,bit22226666_0,bit22226666_1)  \
318p2s_step(p3,p7,simd_himask_8,4,bit33337777_0,bit33337777_1)  \
319p2s_step(bit00004444_0,bit22226666_0,simd_himask_4,2,bit00224466_0,bit00224466_1)  \
320p2s_step(bit11115555_0,bit33337777_0,simd_himask_4,2,bit11335577_0,bit11335577_1)  \
321p2s_step(bit00004444_1,bit22226666_1,simd_himask_4,2,bit00224466_2,bit00224466_3)  \
322p2s_step(bit11115555_1,bit33337777_1,simd_himask_4,2,bit11335577_2,bit11335577_3)  \
323p2s_step(bit00224466_0,bit11335577_0,simd_himask_2,1,s0,s1)  \
324p2s_step(bit00224466_1,bit11335577_1,simd_himask_2,1,s2,s3)  \
325p2s_step(bit00224466_2,bit11335577_2,simd_himask_2,1,s4,s5)  \
326p2s_step(bit00224466_3,bit11335577_3,simd_himask_2,1,s6,s7)  \
327} \
328
329
330void do_process(FILE *infile, FILE *outfile) {
331
332  @decl
333
334  BytePack U8[8];
335  int buf_pos = 0;
336  int block_pos = 0;
337  int errpos = 0;
338  int chars_avail = 0;
339  int check_pos = 0;
340  int chars_read = 0;
341  char buf[BUFFER_SIZE+BLOCK_SIZE+OVERLAP_BUFSIZE*2];
342 
343  char * srcbuf = buf + OVERLAP_BUFSIZE;
344  buffer_base = buf_pos;
345  source = srcbuf;
346 
347  EOF_mask = simd_const_1(1);
348  chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE + OVERLAP_BUFSIZE, infile);
349  chars_avail = min(chars_read,BUFFER_SIZE);
350 
351  if(chars_read<4){
352    fprintf(stderr,"File is too short. Not well formed.\n");
353    exit(-1);
354  }
355 
356  tag_matcher t(srcbuf);
357
358  Entity_Info * e = new Entity_Info;
359  e->AnalyzeSignature((unsigned char *)srcbuf);
360
361  if (e->code_unit_base == ASCII) {
362                       
363    XML_Decl_Parser<ASCII> decl_parser((unsigned char *)srcbuf);
364
365    decl_parser.ReadXMLInfo(*e); 
366   
367    if (e->code_unit_size != SingleByte || (e->has_encoding_decl && (!at_UTF_8(e->encoding)))){
368        fprintf(stderr,"Sorry, we only process UTF-8.\n");
369        exit(-1);
370    }
371  }
372  else {
373    fprintf(stderr,"Sorry, we don't process EBCDIC.\n");
374        exit(-1);
375  }
376 
377  if (e->content_start != 0) {
378        memmove(&srcbuf[0], &srcbuf[e->content_start], chars_read - e->content_start);
379        buf_pos = e->content_start;
380        if (chars_avail == BUFFER_SIZE) {
381                chars_read = chars_read - e->content_start + 
382                             fread(&srcbuf[chars_read-e->content_start], 1, e->content_start, infile);
383                chars_avail = min(chars_read,BUFFER_SIZE);
384        }
385        else {
386          chars_read -=e->content_start;
387          chars_avail -=e->content_start;
388        }
389  }
390 
391  @stream_stmts
392
393  while(1){
394
395    PERF_SEC_START(parser_timer);
396
397    block_pos = 0;
398
399    if(chars_avail < BUFFER_SIZE){
400     
401      while (block_pos <= chars_avail){
402
403        int bytes = chars_avail - block_pos;   
404        block_base = block_pos;
405         
406        if(bytes < BLOCK_SIZE){
407          EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-bytes));
408        }
409        BytePack * U8pack = (BytePack *) &srcbuf[block_pos];
410        U8[0] = sisd_load_unaligned(&U8pack[0]);
411        U8[1] = sisd_load_unaligned(&U8pack[1]);
412        U8[2] = sisd_load_unaligned(&U8pack[2]);
413        U8[3] = sisd_load_unaligned(&U8pack[3]);
414        U8[4] = sisd_load_unaligned(&U8pack[4]);
415        U8[5] = sisd_load_unaligned(&U8pack[5]);
416        U8[6] = sisd_load_unaligned(&U8pack[6]);
417        U8[7] = sisd_load_unaligned(&U8pack[7]); 
418       
419        s2p_bytepack(U8[7], U8[6], U8[5], U8[4], U8[3], U8[2], U8[1], U8[0],
420        array_bit__0_,array_bit__1_,array_bit__2_,array_bit__3_,array_bit__4_,array_bit__5_,array_bit__6_,array_bit__7_);
421
422        array_bit__0_ = simd_and(array_bit__0_, EOF_mask);
423        array_bit__1_ = simd_and(array_bit__1_, EOF_mask);
424        array_bit__2_ = simd_and(array_bit__2_, EOF_mask);
425        array_bit__3_ = simd_and(array_bit__3_, EOF_mask);
426        array_bit__4_ = simd_and(array_bit__4_, EOF_mask);
427        array_bit__5_ = simd_and(array_bit__5_, EOF_mask);
428        array_bit__6_ = simd_and(array_bit__6_, EOF_mask);
429        array_bit__7_ = simd_and(array_bit__7_, EOF_mask);
430
431        @block_stmts
432
433
434        if (bitblock_has_bit(error_mask)) {
435          errpos = block_pos + buf_pos + count_forward_zeroes(error_mask);
436          fprintf(stderr, "error found at position %i\n",errpos);
437          exit(-1);
438        }
439       
440        if (bitblock_has_bit(simd_or(name_check,name_start_check))) {
441          StreamScan((ScanBlock *) &name_start_check, sizeof(BitBlock)/sizeof(ScanBlock), NameStrt_check);
442          StreamScan((ScanBlock *) &name_check, sizeof(BitBlock)/sizeof(ScanBlock), Name_check);
443        }
444         
445        if (bitblock_has_bit(PI_namestarts)){
446          StreamScan((ScanBlock *) &PI_namestarts, sizeof(BitBlock)/sizeof(ScanBlock), PIName_check);
447        }
448       
449        if (bitblock_has_bit(CD_starts)){
450          StreamScan((ScanBlock *) &CD_starts, sizeof(BitBlock)/sizeof(ScanBlock), CD_check);
451        }
452       
453        if (bitblock_has_bit(GenRef2)){
454          StreamScan((ScanBlock *) &GenRef2, sizeof(BitBlock)/sizeof(ScanBlock), GenRef_check);
455        }
456       
457        if (bitblock_has_bit(DecRef3)){
458          StreamScan((ScanBlock *) &DecRef3, sizeof(BitBlock)/sizeof(ScanBlock), DecRef_check);
459        }
460       
461        if (bitblock_has_bit(HexRef4)){
462          StreamScan((ScanBlock *) &HexRef4, sizeof(BitBlock)/sizeof(ScanBlock), HexRef_check);
463        }
464       
465        if (bitblock_has_bit(AttRef)){
466          StreamScan((ScanBlock *) &AttRef, sizeof(BitBlock)/sizeof(ScanBlock), AttRef_check);
467        }
468
469        t.store_streams(tag_marks, NameFollows, Misc_mask, chars_avail);
470       
471        block_pos += BLOCK_SIZE;
472      }
473    }
474    else{
475      while (block_pos < chars_avail){
476       
477        block_base = block_pos;
478         
479        BytePack * U8pack = (BytePack *) &srcbuf[block_pos];
480        U8[0] = sisd_load_unaligned(&U8pack[0]);
481        U8[1] = sisd_load_unaligned(&U8pack[1]);
482        U8[2] = sisd_load_unaligned(&U8pack[2]);
483        U8[3] = sisd_load_unaligned(&U8pack[3]);
484        U8[4] = sisd_load_unaligned(&U8pack[4]);
485        U8[5] = sisd_load_unaligned(&U8pack[5]);
486        U8[6] = sisd_load_unaligned(&U8pack[6]);
487        U8[7] = sisd_load_unaligned(&U8pack[7]); 
488       
489        s2p_bytepack(U8[7], U8[6], U8[5], U8[4], U8[3], U8[2], U8[1], U8[0],
490        array_bit__0_,array_bit__1_,array_bit__2_,array_bit__3_,array_bit__4_,array_bit__5_,array_bit__6_,array_bit__7_);
491
492        @block_stmts
493       
494        if (bitblock_has_bit(error_mask)) {
495          errpos = block_pos + buf_pos + count_forward_zeroes(error_mask);
496          fprintf(stderr, "error found at position %i\n",errpos);
497          exit(-1);
498        }
499       
500        if (bitblock_has_bit(simd_or(name_check,name_start_check))) {
501          StreamScan((ScanBlock *) &name_start_check, sizeof(BitBlock)/sizeof(ScanBlock), NameStrt_check);
502          StreamScan((ScanBlock *) &name_check, sizeof(BitBlock)/sizeof(ScanBlock), Name_check);
503        }
504       
505        if (bitblock_has_bit(PI_namestarts)){
506          StreamScan((ScanBlock *) &PI_namestarts, sizeof(BitBlock)/sizeof(ScanBlock), PIName_check);
507        }
508       
509        if (bitblock_has_bit(CD_starts)){
510          StreamScan((ScanBlock *) &CD_starts, sizeof(BitBlock)/sizeof(ScanBlock), CD_check);
511        }
512       
513        if (bitblock_has_bit(GenRef2)){
514          StreamScan((ScanBlock *) &GenRef2, sizeof(BitBlock)/sizeof(ScanBlock), GenRef_check);
515        }
516       
517        if (bitblock_has_bit(DecRef3)){
518          StreamScan((ScanBlock *) &DecRef3, sizeof(BitBlock)/sizeof(ScanBlock), DecRef_check);
519        }
520       
521        if (bitblock_has_bit(HexRef4)){
522          StreamScan((ScanBlock *) &HexRef4, sizeof(BitBlock)/sizeof(ScanBlock), HexRef_check);
523        }
524       
525        if (bitblock_has_bit(AttRef)){
526          StreamScan((ScanBlock *) &AttRef, sizeof(BitBlock)/sizeof(ScanBlock), AttRef_check);
527        }
528       
529        t.store_streams(tag_marks, NameFollows, Misc_mask, chars_avail);
530
531        block_pos += BLOCK_SIZE;
532      }
533    }
534
535    t.StreamScan(chars_avail);
536    t.Advance_buffer();
537
538    PERF_SEC_END(parser_timer, chars_avail);
539
540    buf_pos += chars_avail;
541    buffer_base = buf_pos;
542    if(chars_avail!=chars_read){
543      int bytes_left = chars_read-chars_avail;
544      memmove(srcbuf, &srcbuf[BUFFER_SIZE], bytes_left);
545      chars_read = fread(&srcbuf[bytes_left],1, BUFFER_SIZE , infile)+bytes_left;
546      chars_avail = min(chars_read,BUFFER_SIZE);
547    }
548    else
549      break;   
550  }
551  if(t.depth!=0){
552    fprintf(stderr, "tag matching error (depth %i) at position %i\n", t.depth, buffer_base);
553    exit(-1);
554  }       
555   
556}
557
558
559
560int
561main(int argc, char * argv[]) {
562        char * infilename, * outfilename;       
563        FILE *infile, *outfile;
564        struct stat fileinfo;
565
566        if (argc < 2) {
567                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
568                exit(-1);
569        }
570
571        infilename = argv[1];
572        stat(infilename, &fileinfo);
573        infile = fopen(infilename, "rb");
574        if (!infile) {
575                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
576                exit(-1);
577        }
578       
579        if (argc < 3) outfile = stdout;
580        else {
581                outfilename = argv[2];
582                outfile = fopen(outfilename, "wb");
583                if (!outfile) {
584                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
585                        exit(-1);
586                }
587        }
588
589//      PERF_SEC_BIND(1);
590
591        PERF_SEC_INIT(parser_timer);
592
593        do_process(infile, outfile);
594       
595        PERF_SEC_DUMP(parser_timer);
596       
597        PERF_SEC_DESTROY(parser_timer);
598
599        fclose(infile);
600        fclose(outfile);
601        return(0);
602}
Note: See TracBrowser for help on using the repository browser.