source: proto/parabix2/template.c @ 590

Last change on this file since 590 was 590, checked in by cameron, 9 years ago

AttRef? check in both template positions

File size: 17.8 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 BUFFER_SIZE 12800   
11#define BLOCK_SIZE 128
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        if (at_XxMmLll<ASCII>((unsigned char*)&source[block_pos]) && (source[block_pos+3]=='?' || source[block_pos+3]<= ' ')) {
167              fprintf(stderr, "[Xx][Mm][Ll] illegal as PI name at position %i\n",block_pos+buffer_base);
168              exit(-1);
169        }
170        return 0;
171}
172
173static inline int CD_check(int pos) {
174        int block_pos = block_base + pos;
175        if (!at_CDATA1<ASCII>((unsigned char*)&source[block_pos])){
176              fprintf(stderr, "CDATA error found at position %i\n",block_pos+buffer_base);
177              exit(-1);
178        }
179        return 0;
180}
181
182static inline int GenRef_check(int pos) {
183        int block_pos = block_base + pos;
184        unsigned char* s = (unsigned char*)&source[block_pos];
185        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))){
186              fprintf(stderr, "Undefined Reference found at position %i\n",block_pos+buffer_base);
187              exit(-1);
188        }
189        return 0;
190}
191
192static inline int HexRef_check(int pos) {
193        int block_pos = block_base + pos;
194        unsigned char* s = (unsigned char*)&source[block_pos];
195        int ch_val = 0;
196        while(at_HexDigit<ASCII>(s)){
197          ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
198          if (ch_val> 0x10FFFF ){
199            fprintf(stderr, "Illegal character reference found at position %i\n",block_pos+buffer_base);
200            exit(-1);
201          }
202          s++;
203        }
204        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
205          fprintf(stderr, "Illegal character reference found at position %i\n",block_pos+buffer_base);
206          exit(-1);
207        }
208        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
209          fprintf(stderr, "Illegal XML 1.0 character reference found at position %i\n",block_pos+buffer_base);
210          exit(-1);
211        }
212        return 0;
213}
214
215static inline int DecRef_check(int pos) {
216        int block_pos = block_base + pos;
217        unsigned char* s = (unsigned char*)&source[block_pos];
218        int ch_val = 0;
219        while(at_HexDigit<ASCII>(s)){
220          ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
221          if (ch_val> 0x10FFFF ){
222            fprintf(stderr, "Illegal character reference found at position %i\n",block_pos+buffer_base);
223            exit(-1);
224          }
225          s++;
226        }
227        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
228          fprintf(stderr, "Illegal character reference found at position %i\n",block_pos+buffer_base);
229          exit(-1);
230        }
231        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
232          fprintf(stderr, "Illegal XML 1.0 character reference found at position %i\n",block_pos+buffer_base);
233          exit(-1);
234        }
235        return 0;
236}
237
238static inline int AttRef_check(int pos) {
239        int block_pos = block_base + pos;
240        unsigned char* s = (unsigned char*)&source[block_pos];
241        int ch_val = 0;
242        if(s[0]=='#'){
243          s++;
244          if(s[0]=='x' or s[0]=='X'){
245            s++;
246            while(at_HexDigit<ASCII>(s)){
247              ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
248              s++;
249            }
250          }
251          else{     
252            while(at_HexDigit<ASCII>(s)){
253              ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
254              s++;
255            }
256          }
257          if (ch_val==60){
258            fprintf(stderr, "Attribute values contain '<' characters after reference expansion at position %i\n",block_pos+buffer_base);
259            exit(-1);
260          }       
261        }
262        else if(at_Ref_lt<ASCII>(s)){
263          fprintf(stderr, "Attribute values contain '<' characters after reference expansion at position %i\n",block_pos+buffer_base);
264          exit(-1);
265        }         
266        return 0;
267}
268
269#define s2p_step(s0,s1,hi_mask,shift,p0,p1)  \
270{ \
271BitBlock t0,t1; \
272t0= simd_pack_16_hh(s0,s1) ; \
273t1= simd_pack_16_ll(s0,s1) ; \
274p0= simd_if(hi_mask,t0,simd_srli_16(t1,shift) ) ; \
275p1= simd_if(hi_mask,simd_slli_16(t0,shift) ,t1) ; \
276} \
277
278#define s2p_bytepack(s0,s1,s2,s3,s4,s5,s6,s7,p0,p1,p2,p3,p4,p5,p6,p7)  \
279{BitBlock bit00224466_0,bit00224466_1,bit00224466_2,bit00224466_3; \
280BitBlock bit11335577_0,bit11335577_1,bit11335577_2,bit11335577_3; \
281BitBlock bit00004444_0,bit22226666_0,bit00004444_1,bit22226666_1; \
282BitBlock bit11115555_0,bit33337777_0,bit11115555_1,bit33337777_1; \
283s2p_step(s0,s1,simd_himask_2,1,bit00224466_0,bit11335577_0)  \
284s2p_step(s2,s3,simd_himask_2,1,bit00224466_1,bit11335577_1)  \
285s2p_step(s4,s5,simd_himask_2,1,bit00224466_2,bit11335577_2)  \
286s2p_step(s6,s7,simd_himask_2,1,bit00224466_3,bit11335577_3)  \
287s2p_step(bit00224466_0,bit00224466_1,simd_himask_4,2,bit00004444_0,bit22226666_0)  \
288s2p_step(bit00224466_2,bit00224466_3,simd_himask_4,2,bit00004444_1,bit22226666_1)  \
289s2p_step(bit11335577_0,bit11335577_1,simd_himask_4,2,bit11115555_0,bit33337777_0)  \
290s2p_step(bit11335577_2,bit11335577_3,simd_himask_4,2,bit11115555_1,bit33337777_1)  \
291s2p_step(bit00004444_0,bit00004444_1,simd_himask_8,4,p0,p4)  \
292s2p_step(bit11115555_0,bit11115555_1,simd_himask_8,4,p1,p5)  \
293s2p_step(bit22226666_0,bit22226666_1,simd_himask_8,4,p2,p6)  \
294s2p_step(bit33337777_0,bit33337777_1,simd_himask_8,4,p3,p7)  \
295} \
296
297#define p2s_step(p0,p1,hi_mask,shift,s0,s1)  \
298{ \
299BitBlock t0,t1; \
300t0= simd_if(hi_mask,p0,simd_srli_16(p1,shift) ) ; \
301t1= simd_if(hi_mask,simd_slli_16(p0,shift) ,p1) ; \
302s0= simd_mergeh_8(t0,t1) ; \
303s1= simd_mergel_8(t0,t1) ; \
304} \
305
306#define p2s_bytemerge(p0,p1,p2,p3,p4,p5,p6,p7,s0,s1,s2,s3,s4,s5,s6,s7)  \
307{ \
308BitBlock bit00004444_0,bit22226666_0,bit00004444_1,bit22226666_1; \
309BitBlock bit11115555_0,bit33337777_0,bit11115555_1,bit33337777_1; \
310BitBlock bit00224466_0,bit00224466_1,bit00224466_2,bit00224466_3; \
311BitBlock bit11335577_0,bit11335577_1,bit11335577_2,bit11335577_3; \
312p2s_step(p0,p4,simd_himask_8,4,bit00004444_0,bit00004444_1)  \
313p2s_step(p1,p5,simd_himask_8,4,bit11115555_0,bit11115555_1)  \
314p2s_step(p2,p6,simd_himask_8,4,bit22226666_0,bit22226666_1)  \
315p2s_step(p3,p7,simd_himask_8,4,bit33337777_0,bit33337777_1)  \
316p2s_step(bit00004444_0,bit22226666_0,simd_himask_4,2,bit00224466_0,bit00224466_1)  \
317p2s_step(bit11115555_0,bit33337777_0,simd_himask_4,2,bit11335577_0,bit11335577_1)  \
318p2s_step(bit00004444_1,bit22226666_1,simd_himask_4,2,bit00224466_2,bit00224466_3)  \
319p2s_step(bit11115555_1,bit33337777_1,simd_himask_4,2,bit11335577_2,bit11335577_3)  \
320p2s_step(bit00224466_0,bit11335577_0,simd_himask_2,1,s0,s1)  \
321p2s_step(bit00224466_1,bit11335577_1,simd_himask_2,1,s2,s3)  \
322p2s_step(bit00224466_2,bit11335577_2,simd_himask_2,1,s4,s5)  \
323p2s_step(bit00224466_3,bit11335577_3,simd_himask_2,1,s6,s7)  \
324} \
325
326
327void do_process(FILE *infile, FILE *outfile) {
328
329  @decl
330
331  BytePack U8[8];
332  int buf_pos = 0;
333  int block_pos = 0;
334  int errpos = 0;
335  int chars_avail = 0;
336  int check_pos = 0;
337  int chars_read = 0;
338  char buf[BUFFER_SIZE+BLOCK_SIZE+OVERLAP_BUFSIZE*2];
339 
340  char * srcbuf = buf + OVERLAP_BUFSIZE;
341  buffer_base = buf_pos;
342  source = srcbuf;
343 
344  EOF_mask = simd_const_1(1);
345  chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE + OVERLAP_BUFSIZE, infile);
346  chars_avail = min(chars_read,BUFFER_SIZE);
347 
348  tag_matcher t(srcbuf);
349
350  Entity_Info * e = new Entity_Info;
351  e->AnalyzeSignature((unsigned char *)srcbuf);
352  XML_Decl_Parser<ASCII> decl_parser((unsigned char *)srcbuf);
353
354  decl_parser.ReadXMLInfo(*e);
355
356  if (e->content_start != 0) {
357        memmove(&srcbuf[0], &srcbuf[e->content_start], chars_read - e->content_start);
358        if (chars_avail == BUFFER_SIZE) {
359                chars_read = chars_read - e->content_start + 
360                             fread(&srcbuf[chars_read-e->content_start], 1, e->content_start, infile);
361                chars_avail = min(chars_read,BUFFER_SIZE);
362        }
363        else {
364          chars_read -=e->content_start;
365          chars_avail -=e->content_start;
366        }
367  }
368 
369  @stream_stmts
370
371  while(1){
372
373    PERF_SEC_START(parser_timer);
374
375    block_pos = 0;
376
377    if(chars_avail < BUFFER_SIZE){
378     
379      while (block_pos < chars_avail){
380
381        int bytes = chars_avail - block_pos;   
382        block_base = block_pos;
383         
384        if(bytes < BLOCK_SIZE){
385          EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-bytes));
386        }
387        BytePack * U8pack = (BytePack *) &srcbuf[block_pos];
388        U8[0] = sisd_load_unaligned(&U8pack[0]);
389        U8[1] = sisd_load_unaligned(&U8pack[1]);
390        U8[2] = sisd_load_unaligned(&U8pack[2]);
391        U8[3] = sisd_load_unaligned(&U8pack[3]);
392        U8[4] = sisd_load_unaligned(&U8pack[4]);
393        U8[5] = sisd_load_unaligned(&U8pack[5]);
394        U8[6] = sisd_load_unaligned(&U8pack[6]);
395        U8[7] = sisd_load_unaligned(&U8pack[7]); 
396       
397        s2p_bytepack(U8[7], U8[6], U8[5], U8[4], U8[3], U8[2], U8[1], U8[0],
398        array_bit__0_,array_bit__1_,array_bit__2_,array_bit__3_,array_bit__4_,array_bit__5_,array_bit__6_,array_bit__7_);
399
400        array_bit__0_ = simd_and(array_bit__0_, EOF_mask);
401        array_bit__1_ = simd_and(array_bit__1_, EOF_mask);
402        array_bit__2_ = simd_and(array_bit__2_, EOF_mask);
403        array_bit__3_ = simd_and(array_bit__3_, EOF_mask);
404        array_bit__4_ = simd_and(array_bit__4_, EOF_mask);
405        array_bit__5_ = simd_and(array_bit__5_, EOF_mask);
406        array_bit__6_ = simd_and(array_bit__6_, EOF_mask);
407        array_bit__7_ = simd_and(array_bit__7_, EOF_mask);
408
409        @block_stmts
410
411
412        if (bitblock_has_bit(error_mask)) {
413          errpos = block_pos + buf_pos + count_forward_zeroes(error_mask);
414          fprintf(stderr, "error found at position %i\n",errpos);
415          exit(-1);
416        }
417       
418        if (bitblock_has_bit(simd_or(name_check,name_start_check))) {
419          StreamScan((ScanBlock *) &name_start_check, sizeof(BitBlock)/sizeof(ScanBlock), NameStrt_check);
420          StreamScan((ScanBlock *) &name_check, sizeof(BitBlock)/sizeof(ScanBlock), Name_check);
421        }
422         
423        if (bitblock_has_bit(PI_namestarts)){
424          StreamScan((ScanBlock *) &PI_namestarts, sizeof(BitBlock)/sizeof(ScanBlock), PIName_check);
425        }
426       
427        if (bitblock_has_bit(CD_starts)){
428          StreamScan((ScanBlock *) &CD_starts, sizeof(BitBlock)/sizeof(ScanBlock), CD_check);
429        }
430       
431        if (bitblock_has_bit(GenRef2)){
432          StreamScan((ScanBlock *) &GenRef2, sizeof(BitBlock)/sizeof(ScanBlock), GenRef_check);
433        }
434       
435        if (bitblock_has_bit(DecRef3)){
436          StreamScan((ScanBlock *) &DecRef3, sizeof(BitBlock)/sizeof(ScanBlock), DecRef_check);
437        }
438       
439        if (bitblock_has_bit(HexRef4)){
440          StreamScan((ScanBlock *) &HexRef4, sizeof(BitBlock)/sizeof(ScanBlock), HexRef_check);
441        }
442       
443        if (bitblock_has_bit(AttRef)){
444          StreamScan((ScanBlock *) &AttRef, sizeof(BitBlock)/sizeof(ScanBlock), AttRef_check);
445        }
446       
447        t.store_streams(tag_marks, NameFollows);
448       
449        block_pos += BLOCK_SIZE;
450      }
451    }
452    else{
453      while (block_pos < chars_avail){
454       
455        block_base = block_pos;
456         
457        BytePack * U8pack = (BytePack *) &srcbuf[block_pos];
458        U8[0] = sisd_load_unaligned(&U8pack[0]);
459        U8[1] = sisd_load_unaligned(&U8pack[1]);
460        U8[2] = sisd_load_unaligned(&U8pack[2]);
461        U8[3] = sisd_load_unaligned(&U8pack[3]);
462        U8[4] = sisd_load_unaligned(&U8pack[4]);
463        U8[5] = sisd_load_unaligned(&U8pack[5]);
464        U8[6] = sisd_load_unaligned(&U8pack[6]);
465        U8[7] = sisd_load_unaligned(&U8pack[7]); 
466       
467        s2p_bytepack(U8[7], U8[6], U8[5], U8[4], U8[3], U8[2], U8[1], U8[0],
468        array_bit__0_,array_bit__1_,array_bit__2_,array_bit__3_,array_bit__4_,array_bit__5_,array_bit__6_,array_bit__7_);
469
470        @block_stmts
471       
472        if (bitblock_has_bit(error_mask)) {
473          errpos = block_pos + buf_pos + count_forward_zeroes(error_mask);
474          fprintf(stderr, "error found at position %i\n",errpos);
475          exit(-1);
476        }
477       
478        if (bitblock_has_bit(simd_or(name_check,name_start_check))) {
479          StreamScan((ScanBlock *) &name_start_check, sizeof(BitBlock)/sizeof(ScanBlock), NameStrt_check);
480          StreamScan((ScanBlock *) &name_check, sizeof(BitBlock)/sizeof(ScanBlock), Name_check);
481        }
482       
483        if (bitblock_has_bit(PI_namestarts)){
484          StreamScan((ScanBlock *) &PI_namestarts, sizeof(BitBlock)/sizeof(ScanBlock), PIName_check);
485        }
486       
487        if (bitblock_has_bit(CD_starts)){
488          StreamScan((ScanBlock *) &CD_starts, sizeof(BitBlock)/sizeof(ScanBlock), CD_check);
489        }
490       
491        if (bitblock_has_bit(GenRef2)){
492          StreamScan((ScanBlock *) &GenRef2, sizeof(BitBlock)/sizeof(ScanBlock), GenRef_check);
493        }
494       
495        if (bitblock_has_bit(DecRef3)){
496          StreamScan((ScanBlock *) &DecRef3, sizeof(BitBlock)/sizeof(ScanBlock), DecRef_check);
497        }
498       
499        if (bitblock_has_bit(HexRef4)){
500          StreamScan((ScanBlock *) &HexRef4, sizeof(BitBlock)/sizeof(ScanBlock), HexRef_check);
501        }
502       
503        if (bitblock_has_bit(AttRef)){
504          StreamScan((ScanBlock *) &AttRef, sizeof(BitBlock)/sizeof(ScanBlock), AttRef_check);
505        }
506       
507        t.store_streams(tag_marks, NameFollows);
508
509        block_pos += BLOCK_SIZE;
510      }
511    }
512
513    t.StreamScan(chars_avail);
514    t.Advance_buffer();
515
516    PERF_SEC_END(parser_timer, chars_avail);
517
518    buf_pos += chars_avail;
519    buffer_base = buf_pos;
520    if(chars_avail!=chars_read){
521      int bytes_left = chars_read-chars_avail;
522      memmove(srcbuf, &srcbuf[BUFFER_SIZE], bytes_left);
523      chars_read = fread(&srcbuf[bytes_left],1, BUFFER_SIZE , infile)+bytes_left;
524      chars_avail = min(chars_read,BUFFER_SIZE);
525    }
526    else
527      break;   
528  }
529  if(t.depth!=0){
530    fprintf(stderr, "tag matching error (depth %i) at position %i\n", t.depth, buffer_base);
531    exit(-1);
532  }       
533   
534}
535
536
537
538int
539main(int argc, char * argv[]) {
540        char * infilename, * outfilename;       
541        FILE *infile, *outfile;
542        struct stat fileinfo;
543
544        if (argc < 2) {
545                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
546                exit(-1);
547        }
548
549        infilename = argv[1];
550        stat(infilename, &fileinfo);
551        infile = fopen(infilename, "rb");
552        if (!infile) {
553                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
554                exit(-1);
555        }
556       
557        if (argc < 3) outfile = stdout;
558        else {
559                outfilename = argv[2];
560                outfile = fopen(outfilename, "wb");
561                if (!outfile) {
562                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
563                        exit(-1);
564                }
565        }
566
567//      PERF_SEC_BIND(1);
568
569        PERF_SEC_INIT(parser_timer);
570
571        do_process(infile, outfile);
572       
573        PERF_SEC_DUMP(parser_timer);
574       
575        PERF_SEC_DESTROY(parser_timer);
576
577        fclose(infile);
578        fclose(outfile);
579        return(0);
580}
Note: See TracBrowser for help on using the repository browser.